codeparrot-small-multi

TULLUS = I quickly converted the model.bin to model.safetensors file after pulling the base repo.

A few weeks ago i made a mini gradio server that was special built for running a multimodal. So now i made it load the new artifac, and more INFOS Below ⬇

CodeParrot-Multi (small)

CodeParrot-Multi is a GPT-2 model (110M parameters) trained to generate code in 9 programming languages: "Java", "JavaScript", "PHP", "Python", "C#", "C++", "GO", "Ruby" and "TypeScript".

New Usage for the model.safetensors :]

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "TULLUS/codeparrot-small-multi"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)

prompt = "def hello_world():"
inputs = tokenizer(prompt, return_tensors="pt")

with torch.no_grad():
    outputs = model.generate(
        **inputs, 
        max_new_tokens=32,
        pad_token_id=tokenizer.eos_token_id
    )

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Older pythorch.model.bin Usage

You can load the CodeParrot-Multi model and tokenizer directly in transformers:

from transformers import AutoTokenizer, AutoModelWithLMHead

tokenizer = AutoTokenizer.from_pretrained("codeparrot/codeparrot-small-multi")
model = AutoModelWithLMHead.from_pretrained("codeparrot/codeparrot-small-multi")

inputs = tokenizer("def hello_world():", return_tensors="pt")
outputs = model(**inputs)

or with a pipeline:

from transformers import pipeline

pipe = pipeline("text-generation", model="codeparrot/codeparrot-small-multi")
outputs = pipe("def hello_world():")

Training

The model was trained on the small Github code small after near deduplication, a subset of Github code dataset with the following settings:

The training was executed on 16 x A100 (40GB) GPUs. This setting amounts to roughly 58 billion tokens.

Performance

We evaluated the model on OpenAI's HumanEval benchmark which consists of programming challenges:

The pass@k metric tells the probability that at least one out of k generations passes the tests.

Resources

• Code: repository

TULLUS Edits

Laboratory initialized. Ready for input.

import time
import torch
import json
import base64
import io
import logging
import os
from typing import Optional, Dict, Any
from PIL import Image
from fastapi import FastAPI, HTTPException
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse
from pydantic import BaseModel
from transformers import AutoTokenizer, AutoModelForCausalLM
import uvicorn
import transformers


# --- Configuration ---
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
MODEL_PATH = "TULLUS"

These stats load at runtime start in my mini server. ```raw miniserver side panel outputs ▶ MODEL { "name": "gpt2", "architecture": "['GPT2LMHeadModel']", "parameters": "111,008,256", "dtype": "torch.float16" }

RUNTIME { "transformers_version": "5.15.0", "pytorch_version": "2.9.1+rocm7.2.1.gitff65f5bc", "rocm_hip": "7.2.53211-e1a6bc5663", "python_version": "3.12.13" }

▶ GPU { "0": { "name": "AMD Radeon RX 9070 XT", "total_memory": "15.92 GiB", "current_memory": "15.12 GiB" } }

---

# Code completion prompt (model fills in the rest):
"def add_numbers(a, b):\n return"

```code
"def add_numbers(a, b):\n return"
+ a.toString() + " + b.toString();",
"def add_strings(a, b):\n return" + a.toString() + " = 'abc' + b.toString();\n",
"def add_ints(a, b):\n return" + a.toString() + " = 1 + 2;\n",
"def add_floats(a, b):\n return" + a.toString() + " = 3.1415926535897932384626433832795;\n",
"def add_doubles(

• Stats

{
  "input_tokens": 15,
  "output_tokens": 128,
  "generation_time_sec": 1.068,
  "tokens_per_sec": 119.84,
  "parameters_used": {
    "max_new_tokens": 128,
    "temperature": 0.2,
    "top_p": 0.95,
    "do_sample": true,
    "repetition_penalty": 1.2,
    "pad_token_id": 0,
    "eos_token_id": 0
  }
}

Java completion prompt:

"public class Main {\n public static int add(int a, int b) {\n"

+
" return a+b;\n" +
"}\n\n");
}

@Test
void testAdd() {
assertParse("public class Main {\n public static int add(int a, int b) {\n" +
" return a+b; }\n}\n", false);

assertParse("public class Main {\n public static int add(int a, int b) {\n" +
" return a+b; }\n}\n", true);

assertParse("public class Main {\n public static int add(int a, int b) {\

• Stats

{
  "input_tokens": 20,
  "output_tokens": 128,
  "generation_time_sec": 1.043,
  "tokens_per_sec": 122.69,
  "parameters_used": {
    "max_new_tokens": 128,
    "temperature": 0.2,
    "top_p": 0.95,
    "do_sample": true,
    "repetition_penalty": 1.2,
    "pad_token_id": 0,
    "eos_token_id": 0
  }
}

// Convert Python dictionary lookup logic to C++ std::map // Python: val = my_dict.get(key, -1)

include

include

int get_value_or_default(const std::map& my_dict, const std::string& key) {

if (my_dict.find(key) != my_dict.end())
return my_dict[key];

// Default value is 0
return 0;
}

• Stats

{
  "input_tokens": 76,
  "output_tokens": 40,
  "generation_time_sec": 0.823,
  "tokens_per_sec": 48.61,
  "parameters_used": {
    "max_new_tokens": 128,
    "temperature": 0.2,
    "top_p": 0.95,
    "do_sample": true,
    "repetition_penalty": 1.2,
    "pad_token_id": 0,
    "eos_token_id": 0
  }
}