The model was quantized into the GGUF format using MXFP4, with the output tensor type and token embedding type set to Q8_0 to maximize quality and minimize potential degradation. This quantized model represents a balanced solution between the variant with all transformer layers in MXFP4 and the variant with MXFP4 layers except for the output tensor and token embedding, which remain in BF16.

Special thanks to Bartowski for providing the source imatrix calibration file.

The model is designed for systems with at least 32GB of RAM (Linux PC, Windows PC, Apple PC). For Linux and Windows systems, a 16-core processor and an RTX 3080, 4070+, or 5060+ GPU are recommended.

Model Details

Model Description

This is a fine-tuned version of openai/gpt-oss-20b, optimized for high-quality Java code generation. SonarSweep was used to create a high-quality Java dataset. Fine-tuning on this dataset has produced a model that generates expert-level Java patterns while avoiding the bugs and vulnerabilities observed when benchmarking the base model.

Developed by: Sonar SonarSweep Team
Model type: Mixture of Experts
Languages: Primarily Java, English
License: Apache 2.0

Uses

This model is designed primarily as a demonstration of our SonarSweep pipeline, specifically for fine-tuning on Java.

By using SonarSweep for targeted data preprocessing, pass@1 metrics are maintained across all coding benchmarks, while the number of bugs and vulnerabilities is significantly reduced compared to the base model.

Despite being a demonstration model, we have tested the model to ensure its responses are helpful, natural, and adhere to instructions. We have evaluated a range of benchmarks across software engineering and general use cases to ensure the model remains widely useful.

We focus on gpt-oss-20b in the "low" reasoning setting, which we refer to as gpt-oss-20b-low. In this setting, the base model responds quickly and achieves relatively high scores in code generation benchmarks. This configuration would be appropriate, for example, for developers using an LLM for in-line completions.

As with the base model, the fine-tuned model was trained on data in OpenAI's harmony response format. The model should only be used with the harmony format, as it will not work correctly otherwise.

Technical recommendations for usage are included below; see Getting Started.

Reasoning Capabilities

This model operates exclusively as a low-reasoning model, derived from gpt-oss-20b-low. It is optimized for speed and standard conversational tasks rather than complex chain-of-thought processing.

Please note that specifying or adjusting reasoning effort is not supported. Any parameters attempting to enforce "medium" or "high" reasoning settings will be ignored or may result in an error. The model is hard-coded to a low-reasoning profile.

Bias, Risks, and Limitations

Despite being trained to output high-quality Java code and achieving substantial improvements on our code quality benchmarks, the model is still liable to generate bugs and security vulnerabilities. Users must never treat generated code as production-ready without a thorough review using static analysis—for example, using SonarQube.

Our model's (and the base model's) knowledge is static, based on its training data cutoff. We cannot guarantee adherence to the latest Java standards, best practices in newly released libraries, or correct use of private or proprietary APIs.

Getting Started

You can use the SonarSweep-java-gpt-oss-20b model with Transformers. If you use the Transformers chat template, it will automatically apply the harmony response format. If you use model.generate directly, you need to apply the harmony format manually using the chat template.

Minimum Requirements

GPU Memory: 48GB+ VRAM required for the model loaded in bf16 precision
Storage: 100GB

To get started, install the necessary dependencies to set up your environment:

pip install -U transformers kernels torch

Once installed, you can run the model using the following snippet:

python

from transformers import pipeline
model_id = "SonarSource/SonarSweep-java-gpt-oss-20b"
pipe = pipeline(
    "text-generation",
    model=model_id,
    torch_dtype="auto",
    device_map="auto",
)
messages = [
    {"role": "user", "content": "Write a function in Java that creates a two-dimensional array with 5 rows and 2 columns, each element of which is a random number between 1 and 50."},
]
outputs = pipe(
    messages,
    max_new_tokens=2048,
)
print(outputs[0]["generated_text"][-1])

For more details see here.

Training Details

Training Data

We compiled open-source code data from OpenCoder Datasets and synthetic alignment data generated using openai/gpt-oss-120b to create a Java dataset of 70k examples. We then used SonarSweep to improve the quality of the dataset.

Training Hyperparameters

We trained LoRA adapters across all linear layers of the experts and attention blocks.

Parameter	Value
Batch Size	64
Training Epochs	2
Learning Rate	1e-4
LR Scheduler	Cosine with 10% Warmup
LoRA Rank	64
LoRA Alpha	128
Attention Mechanism	SDPA
Precision	bf16 mixed precision

Model Architecture

Property	Value
Architecture	gpt-oss (Transformer-based Mixture of Experts)
Parameters	20.9 billion (3.6 billion active)
Trainable Parameters	740M (3.4% of total)

Evaluation

Code Quality

We used SonarQube to evaluate the quality, verbosity, and complexity of Java code generated for the ComplexCodeEval and MultiPL-E Java benchmarks.

The fine-tuned and base models achieve a similar pass@1 metric for code generation (within 1% difference). Results for other languages are shown in the next subsection.

The fine-tuned model achieves this metric while generating fewer lines of code.

For code quality, we see a dramatic reduction in both the number and density of Sonar issues, split among bugs, security vulnerabilities, and code smells (see the Glossary for definitions).

Metric	Base Model	Fine-tuned Model
MultiPL-E Pass@1	71.49	72.37
Lines of Code Generated	247,895	233,031
Bugs Generated	222	123
Bugs per KLOC	0.9	0.53
Security Vulnerabilities	102	56
Vulnerabilities per KLOC	0.41	0.24
Code Smells	4,968	3,796
Code Smells per KLOC	20.04	16.29

For cyclomatic and cognitive complexity, after fine-tuning, there was a reduction in both total complexity and complexity per thousand lines of code.

Complexity Metric	Base Model	Fine-tuned Model
Cyclomatic (Total)	52,139	45,006
Cyclomatic (per KLOC)	210.33	193.13
Cognitive (Total)	30,871	24,419
Cognitive (per KLOC)	124.53	104.79

Note: KLOC = Thousand Lines of Code.

Code Generation

MultiPL-E provides a multilanguage parallel benchmark for evaluating the performance of LLMs on natural-language-to-code generation tasks. For each language, they provide a translated version of HumanEval and MBPP.

We fine-tuned on Java but chose to evaluate a selection of available languages. For all languages, scores are averages of 10 samples with temperature set to 0.01.

Results

The changes are not significant for any language; this demonstrates that we do not see performance degradation in the fine-tuned model's ability to generate functional code.

Language	Dataset	Num Examples	Base Model Pass@1	Fine-tuned Model Pass@1
Java	HumanEval	158	85.40%	84.50%
Java	MBPP	386	65.80%	67.40%
Python	HumanEval	164	43.06%	47.39%
Python	MBPP*	257	26.50%	29.89%
PHP	MBPP	397	63.20%	65.80%
TypeScript	MBPP	390	74.10%	73.00%
Go	MBPP	374	35.00%	36.90%

* This is the sanitized MBPP benchmark from the original Google Research paper.

General Ability: MMLU

The MMLU (Massive Multitask Language Understanding) benchmark evaluates the model's general knowledge with 14,042 multiple-choice questions across a wide range of subjects.

Metric	Base Model	Fine-tuned Model
Correct Answers	11,081	10,969
Accuracy	78.91%	78.12%

The fine-tuned model maintains comparable performance on MMLU with only a 0.79% decrease in accuracy, demonstrating that specialization in Java code quality does not significantly impact general knowledge capabilities.

Glossary

SonarSweep: A pipeline that analyzes and remediates code for training datasets. For more details, see the announcement on sonarsource.com.

Lines of Code (LOC): The number of lines of code generated, not counting comments or blank lines. For our scale, KLOC (thousand lines of code) is more appropriate.

Code Quality: Using static analysis, SonarQube specifically monitors and measures three core software qualities, each of which has an associated type of issue:

Security: The protection of your software from unauthorized access, use, or destruction. Detected security issues are called Vulnerabilities.
Reliability: A measure of how your software is capable of maintaining its level of performance under stated conditions for a stated period of time. Detected reliability issues are called Bugs.
Maintainability: Refers to the ease with which you can repair, improve, and understand software code. Detected maintainability issues are called Code Smells.

SonarQube analysis for Java supports the detection of a wide range of quality issues. For details, see rules.sonarsource.com.

Acknowledgements

Base Model: openai/gpt-oss-20b
Code Quality Assessment Methodology: Assessing the Quality and Security of AI-Generated Code: A Quantitative Analysis
Benchmarks:
- ComplexCodeEval: https://arxiv.org/abs/2409.10280
- MultiPL-E: https://arxiv.org/abs/2208.08227
- MMLU: https://arxiv.org/abs/2009.03300
- MBPP: https://arxiv.org/abs/2108.07732 | Code
OpenCoder: https://opencoder-llm.github.io/

Model Card Authors

SonarSweep Team

For feedback: https://community.sonarsource.com/

ROMANIAN

Cuantizare llama.cpp

Am realizat cuantizarea modelului în format-ul GGUF tip MXFP4 cu tipul tensorului de ieșire și tipul încorporării de token Q8_0 pentru a maximiza calitatea și a reduce posibila degradare. Modelul cuantificat este soluția echilibrată între varianta cu toate straturile transformer MXFP4 și varianta cu straturi MXFP4 cu excepția tensorului de ieșire și încorporării de token BF16.

Mulțumiri speciale lui Bartowski pentru fișier sursă imatrix de calibrare.

Modelul este destinat sistemelor cu cel puțin 32GB RAM (Linux PC, Windows PC, Apple PC); Pentru sisteme Linux, Windows este recomandat procesor cu 16 nuclee și videocard RTX 3080, 4070+, 5060+;

Descrierea modelului

Acest model reprezintă o versiune optimizată a arhitecturii openai/gpt-oss-20b, special adaptată pentru generarea de cod Java de înaltă calitate. Procesul de rafinare s-a bazat pe un set de date Java curat și riguros selectat, creat cu ajutorul instrumentului SonarSweep, dezvoltat de SonarSource. Prin aplicarea acestui proces de optimizare, modelul rezultat generează modele de cod Java la nivel de expert, evitând în același timp erorile și vulnerabilitățile identificate în evaluările comparative efectuate asupra modelului de bază.

Modelul a fost dezvoltat de echipa SonarSweep și se încadrează în categoria Mixture of Experts (MoE), fiind destinat în principal generării de cod Java, dar și interacțiunilor în limba engleză. Licența sub care este distribuit este Apache 2.0, asigurând astfel compatibilitate cu utilizări comerciale și adaptări ulterioare.

Utilizări și aplicații

Scopul principal al acestui model este de a demonstra capabilitățile pipeline-ului SonarSweep, în special în contextul rafinării modelelor pentru generarea de cod Java. Prin utilizarea SonarSweep în etapa de preprocesare țintită a datelor, modelul reușește să mențină metricile pass@1 la un nivel ridicat în cadrul benchmark-urilor de programare, reducând în același timp semnificativ numărul de erori și vulnerabilități comparativ cu modelul de bază.

Deși este conceput ca un model demonstrativ, SonarSweep Java gpt-oss-20b a fost supus unor teste riguroase pentru a asigura că răspunsurile generate sunt utile, naturale și conforme cu instrucțiunile primite. Evaluările au acoperit o gamă largă de scenarii, de la inginerie software până la utilizări generale, confirmând astfel versatilitatea modelului.

În cadrul acestui proiect, accentul a fost pus pe varianta „low reasoning” a modelului de bază, denumită gpt-oss-20b-low. Această configurație este optimizată pentru viteză și sarcini conversaționale standard, fiind potrivită, de exemplu, pentru dezvoltatorii care utilizează un model de limbaj pentru completări în linie. Modelul rafinat, la fel ca și versiunea originală, a fost antrenat pe date structurate în formatul de răspuns Harmony dezvoltat de OpenAI, disponibil aici. Este esențial ca modelul să fie utilizat exclusiv în acest format, deoarece alte abordări pot compromite funcționalitatea sa. Pentru recomandări tehnice detaliate, consultați secțiunea Începerea utilizării.

Capabilități de raționament

Modelul SonarSweep Java gpt-oss-20b funcționează exclusiv în regim de raționament redus, fiind derivat direct din varianta gpt-oss-20b-low. Această configurație este optimizată pentru viteză și sarcini conversaționale standard, nu pentru procesarea complexă de tip chain-of-thought. Este important de reținut că modelul nu permite ajustarea nivelului de raționament; orice parametru care încearcă să impună setări de tip „medium” sau „high” va fi ignorat sau poate genera erori. Profilul de raționament al modelului este hardcodat la nivel redus, asigurând astfel consistență în performanță pentru sarcinile pentru care a fost proiectat.

Bias, riscuri și limitări

Deși modelul a fost antrenat pentru a genera cod Java de înaltă calitate și a înregistrat îmbunătățiri semnificative în cadrul benchmark-urilor de calitate a codului, există riscul ca acesta să genereze în continuare erori și vulnerabilități de securitate. Utilizatorii trebuie să evite considerarea codului generat ca fiind pregătit pentru producție fără o verificare amănunțită, preferabil prin analiză statică, de exemplu cu ajutorul instrumentului SonarQube.

Cunoștințele modelului, la fel ca și cele ale versiunii de bază, sunt statice, fiind bazate pe data de tăiere a setului de antrenare. Astfel, nu se poate garanta respectarea celor mai recente standarde Java, a celor mai bune practici din bibliotecile recent lansate sau utilizarea corectă a API-urilor private sau proprietare. Utilizatorii trebuie să fie conștienți de aceste limitări și să valideze independent orice cod generat înainte de integrarea acestuia în proiecte critice.

Începerea utilizării

Modelul SonarSweep-java-gpt-oss-20b poate fi utilizat cu biblioteca Transformers. Dacă folosiți șablonul de chat al Transformers, formatul de răspuns Harmony va fi aplicat automat. În cazul în care utilizați direct metoda model.generate, va trebui să aplicați manual formatul Harmony folosind șablonul de chat.

Cerințe minime de sistem:

Memorie GPU: minim 48GB VRAM pentru încărcarea modelului în precizia bf16;
Spațiu de stocare: 100GB disponibili.

Pentru a începe, instalați dependențele necesare configurării mediului de lucru:

pip install -U transformers kernels torch

După instalare, modelul poate fi rulat folosind următorul fragment de cod:

python

from transformers import pipeline
model_id = "SonarSource/SonarSweep-java-gpt-oss-20b"
pipe = pipeline(
    "text-generation",
    model=model_id,
    torch_dtype="auto",
    device_map="auto",
)
messages = [
    {"role": "user", "content": "Scrie o funcție în Java care creează un tablou bidimensional cu 5 rânduri și 2 coloane, fiecare element fiind un număr aleatoriu între 1 și 50."},
]
outputs = pipe(
    messages,
    max_new_tokens=2048,
)
print(outputs[0]["generated_text"][-1])

Pentru mai multe detalii, consultați documentația oficială aici.

Detalii despre antrenare

Datele de antrenare au fost compilate din cod open-source preluat din OpenCoder Datasets și din date sintetice de aliniere generate cu ajutorul modelului openai/gpt-oss-120b, rezultând un set de date Java format din 70.000 de exemple. Ulterior, calitatea acestui set de date a fost îmbunătățită folosind SonarSweep.

Hiperparametrii de antrenare au inclus aplicarea adaptorilor LoRA pe toate straturile liniare ale experților și blocurilor de atenție. Principalii parametri utilizați au fost:

Dimensiunea lotului: 64;
Numărul de epoci de antrenare: 2;
Rata de învățare: 1e-4;
Planificatorul ratei de învățare: Cosinus, cu 10% warmup;
Rangul LoRA: 64;
Alpha LoRA: 128;
Mecanismul de atenție: SDPA (Scaled Dot-Product Attention);
Precizia: bf16 mixed precision.

Arhitectura modelului se bazează pe un model Transformer de tip Mixture of Experts (MoE), cu un total de 20,9 miliarde de parametri, dintre care 3,6 miliarde sunt activi în timpul inferenței. Dintre aceștia, 740 de milioane de parametri (3,4% din total) sunt antrenabili, restul rămânând fixați.

Evaluare

Calitatea codului a fost evaluată folosind SonarQube, analizând verbozitatea, complexitatea și calitatea generală a codului Java generat pentru benchmark-urile ComplexCodeEval și MultiPL-E Java.

Atât modelul rafinat, cât și cel de bază, au obținut metrici pass@1 similare pentru generarea de cod, diferența fiind de sub 1%. Totuși, modelul rafinat a generat mai puține linii de cod, demonstrând o eficiență sporită. În ceea ce privește calitatea codului, s-a observat o reducere dramatică atât a numărului, cât și a densității problemelor identificate de Sonar, împărțite în bug-uri, vulnerabilități de securitate și mirosuri de cod (vezi Glossarul pentru definiții).

Metrică	Model de bază	Model rafinat
MultiPL-E Pass@1	71,49%	72,37%
Linii de cod generate	247.895	233.031
Bug-uri generate	222	123
Bug-uri per KLOC	0,9	0,53
Vulnerabilități de securitate	102	56
Vulnerabilități per KLOC	0,41	0,24
Mirosuri de cod	4.968	3.796
Mirosuri de cod per KLOC	20,04	16,29

În ceea ce privește complexitatea ciclomatică și cognitivă, modelul rafinat a înregistrat reduceri semnificative atât la nivelul complexității totale, cât și al complexității raportate la o mie de linii de cod (KLOC).

Metrică de complexitate	Model de bază	Model rafinat
Ciclomatică (total)	52.139	45.006
Ciclomatică (per KLOC)	210,33	193,13
Cognitivă (total)	30.871	24.419
Cognitivă (per KLOC)	124,53	104,79

Nota: KLOC = O mie de linii de cod.

Generarea de cod

Benchmark-ul MultiPL-E oferă un cadru de evaluare paralel multilingvistic pentru testarea performanței modelelor de limbaj în sarcini de generare de cod din limbaj natural. Pentru fiecare limbaj evaluat, sunt disponibile versiuni traduse ale benchmark-urilor HumanEval și MBPP.

Deși modelul a fost rafinat exclusiv pe cod Java, evaluările au fost extinse și asupra altor limbaje de programare. Pentru toate limbajele testate, scorurile reprezintă medii calculate pe 10 eșantioane, cu temperatura setată la 0,01. Rezultatele demonstrează că rafinarea nu a afectat negativ capacitatea modelului de a genera cod funcțional, diferențele fiind nesemnificative.

Limbaj	Set de date	Număr de exemple	Model de bază Pass@1	Model rafinat Pass@1
Java	HumanEval	158	85,40%	84,50%
Java	MBPP	386	65,80%	67,40%
Python	HumanEval	164	43,06%	47,39%
Python	MBPP*	257	26,50%	29,89%
PHP	MBPP	397	63,20%	65,80%
TypeScript	MBPP	390	74,10%	73,00%
Go	MBPP	374	35,00%	36,90%

Acesta este benchmark-ul MBPP sanitizat, derivat din articolul original Google Research.

Capacități generale: MMLU

Benchmark-ul MMLU (Massive Multitask Language Understanding) evaluează cunoștințele generale ale modelului prin intermediul a 14.042 de întrebări cu răspunsuri multiple, acoperind o gamă largă de domenii.

Metrică	Model de bază	Model rafinat
Răspunsuri corecte	11.081	10.969
Acuratețe	78,91%	78,12%

Modelul rafinat și-a menținut performanțele comparabile în cadrul benchmark-ului MMLU, înregistrând o scădere de doar 0,79% a acurateței. Acest rezultat demonstrează că specializarea pe calitatea codului Java nu a afectat semnificativ capacitățile generale de cunoaștere ale modelului.

Glossar

SonarSweep reprezintă un pipeline de analiză și remediere a codului destinat îmbunătățirii seturilor de date utilizate în antrenarea modelelor. Pentru mai multe detalii, consultați anunțul oficial pe sonarsource.com.

Linii de cod (LOC) se referă la numărul de linii de cod generate, excluzând comentariile și liniile goale. La scară mare, este mai relevantă utilizarea KLOC (o mie de linii de cod).

Calitatea codului este evaluată prin analiză statică, SonarQube monitorizând și măsurând trei calități fundamentale ale software-ului, fiecare asociată unui tip specific de problemă:

Securitatea se referă la protecția software-ului împotriva accesului neautorizat, utilizării improprii sau distrugerii. Problemele de securitate detectate sunt denumite vulnerabilități.
Fiabilitatea reprezintă capacitatea software-ului de a-și menține nivelul de performanță în condițiile specificate, pe o perioadă determinată. Problemele de fiabilitate identificate sunt denumite bug-uri.
Mentenabilitatea indică ușurința cu care codul poate fi reparat, îmbunătățit sau înțeles. Problemele de mentenabilitate detectate sunt denumite mirosuri de cod (code smells).

Analiza SonarQube pentru Java suportă detectarea unei game largi de probleme de calitate. Pentru detalii, consultați rules.sonarsource.com.

Mulțumiri

Modelul de bază: openai/gpt-oss-20b;
Metodologia de evaluare a calității și securității codului generat de IA: Assessing the Quality and Security of AI-Generated Code: A Quantitative Analysis;
Benchmark-uri:
- ComplexCodeEval: https://arxiv.org/abs/2409.10280;
- MultiPL-E: https://arxiv.org/abs/2208.08227;
- MMLU: https://arxiv.org/abs/2009.03300;
- MBPP: https://arxiv.org/abs/2108.07732 | Cod sursă;
OpenCoder: https://opencoder-llm.github.io/.

Autorii fișei modelului

Echipa SonarSweep

Pentru feedback, accesați: https://community.sonarsource.com/.

watchfoxie/SonarSweep-java-gpt-oss-20b-GGUF

SonarSweep Java gpt-oss-20b

llama.cpp Quantization