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

SonarSweep Java gpt-oss-20b

ENGLISH

llama.cpp Quantization

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:

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.

Model Architecture

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).

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

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.

* 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.

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:

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).

Î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).

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.

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.

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/.