Qwen2.5-Coder: Un asistent de programare avansat

Deviza noului model Qwen2.5-Coder este “Code More, Learn More”, adică “codează mai mult, învață mai mult” și acestea nu par doar cuvinte în vânt.

1. Modelele AI specializate pentru asistență în programare

În era digitală actuală, programarea și dezvoltarea software-ului au devenit domenii esențiale pentru progresul tehnologic și inovație. Pe măsură ce complexitatea proiectelor software crește, nevoia de instrumente și asistență avansată pentru programatori devine tot mai acută. În acest context, modelele de inteligență artificială specializate în asistența pentru programare au apărut ca o soluție promițătoare.

Aceste modele AI sunt concepute pentru a înțelege și genera cod în diverse limbaje de programare, oferind programatorilor un partener virtual capabil să îi ajute în sarcinile lor zilnice. Ele pot asista în generarea de cod, completarea automată, depanare, și chiar în explicarea conceptelor complexe de programare.

Unul dintre cele mai recente și avansate modele în această categorie este Qwen2.5-Coder, dezvoltat de echipa Qwen. Acest model reprezintă o evoluție semnificativă în domeniul asistenței AI pentru programare, aducând o serie de îmbunătățiri și capacități noi care îl diferențiază de predecesorii săi.

Qwen2.5-Coder face parte din familia de modele Qwen2.5, (continuatoarele Qwen2) care include versiuni de diferite dimensiuni pentru a se potrivi diverselor nevoi și resurse computaționale. Disponibil în variantele de 1.5B, 7B și o viitoare versiune de 32B, Qwen2.5-Coder este proiectat să fie un asistent de programare versatil și puternic, capabil să înțeleagă și să genereze cod în nu mai puțin de 92 de limbaje de programare.

Ce face ca Qwen2.5-Coder să fie special este abordarea sa holistică. În timp ce se concentrează pe îmbunătățirea abilităților de programare, modelul menține și dezvoltă în continuare capacitățile în domenii conexe precum matematica și sarcinile generale. Această abordare multidisciplinară face din Qwen2.5-Coder nu doar un simplu generator de cod, ci un asistent inteligent capabil să înțeleagă contextul mai larg al proiectelor de dezvoltare software.

2. Avantajele Qwen2.5-Coder

Qwen2.5-Coder aduce o serie de avantaje semnificative care îl poziționează ca unul dintre cele mai avansate modele de asistență AI pentru programare disponibile în prezent, alături de Codestral sau Mamba. Iată câteva dintre principalele sale puncte forte:

a) Acoperire extinsă a limbajelor de programare

Unul dintre cele mai impresionante aspecte ale Qwen2.5-Coder este suportul său pentru 92 de limbaje de programare. Această acoperire largă înseamnă că, indiferent de stiva tehnologică pe care o utilizează un dezvoltator, există o mare probabilitate ca Qwen2.5-Coder să poată oferi asistență valoroasă. De la limbaje populare precum Python, Java și JavaScript, până la limbaje mai specializate sau mai puțin comune, Qwen2.5-Coder este pregătit să ofere suport.

b) Înțelegere și generare de context lung

Qwen2.5-Coder poate procesa și genera secvențe de până la 128K tokens. Această capacitate de a lucra cu contexte lungi este crucială în programare, unde înțelegerea structurii complete a unui program sau a unui fișier de cod este esențială pentru generarea de cod relevant și corect.

c) Abilitați avansate de completare și generare de cod

Modelul excelează în sarcini precum completarea de cod, generarea de cod multi-programare, și repararea codului. Aceste capabilități pot accelera semnificativ procesul de dezvoltare, ajutând programatorii să scrie cod mai rapid și să identifice și să corecteze erori mai eficient.

d) Raționament bazat pe cod

Qwen2.5-Coder nu doar generează cod, ci demonstrează și abilități avansate de raționament bazat pe cod. Această capacitate îi permite să înțeleagă logica din spatele codului, facilitând rezolvarea de probleme complexe și oferind explicații detaliate atunci când este necesar.

e) Abilități matematice și generale robuste

Pe lângă expertiza sa în programare, Qwen2.5-Coder menține performanțe puternice în domenii conexe precum matematica și sarcinile generale. Această versatilitate îl face util nu doar pentru scrierea de cod, ci și pentru rezolvarea problemelor matematice complexe sau pentru asistență în alte aspecte ale dezvoltării software.

f) Capacități de învățare și adaptare

Deși Qwen2.5-Coder nu poate “învăța” în timp real din interacțiunile cu utilizatorii, modelul a fost antrenat pe un set vast de date care include cod sursă, date de ancorare text-cod și date sintetice, totalizând 5,5 trilioane de tokens. Această bază de cunoștințe extinsă îi permite să se adapteze la o varietate largă de scenarii și stiluri de programare.

g) Suport pentru programare la nivel de fișier și repozitoriu

Qwen2.5-Coder poate înțelege și lucra cu structuri de cod la nivel de fișier și chiar la nivel de repozitoriu. Această capacitate este deosebit de utilă pentru proiecte mari și complexe, unde înțelegerea relațiilor dintre diferite fișiere și module este crucială.

h) Performanțe competitive

În diverse evaluări, Qwen2.5-Coder a demonstrat performanțe competitive sau chiar superioare față de modele mai mari sau mai cunoscute. Acest lucru îl face o opțiune atractivă pentru organizații și dezvoltatori individuali care caută un echilibru între performanță și eficiență în utilizarea resurselor.

3. Cum să instalăm Qwen2.5-Coder local

Pentru dezvoltatorii și organizațiile care doresc să utilizeze Qwen2.5-Coder local, procesul este destul de simplu și direct. Iată un ghid pas de pe GitHub pentru a începe:

a) Cerințe de sistem

Înainte de a începe, asigurați-vă că sistemul dvs. îndeplinește cerințele minime:

• Python 3.9 sau o versiune mai recentă
• Transformers 4.37.0 sau o versiune mai recentă (acest lucru este crucial, deoarece Transformers a integrat codul pentru Qwen2 începând cu versiunea 4.37.0)

b) Instalarea pachetelor necesare

Puteți instala toate pachetele necesare utilizând următoarea comandă:

pip install -r requirements.txt

c) Încărcarea modelului și a tokenizer-ului

Pentru a începe să utilizați Qwen2.5-Coder, trebuie să încărcați modelul și tokenizer-ul. Iată un exemplu de cod pentru a face acest lucru:

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Qwen/Qwen2.5-Coder-7B"

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)

tokenizer = AutoTokenizer.from_pretrained(model_name)

d) Generarea de cod

Odată ce modelul și tokenizer-ul sunt încărcate, puteți începe să generați cod. Iată un exemplu simplu:

prompt = "write a quick sort algorithm."

messages = [
    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},
    {"role": "user", "content": prompt}
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=512
)

generated_ids = [
    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]

response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]

print(response)

e) Completarea codului la nivel de fișier

Pentru sarcini mai complexe, cum ar fi completarea codului la nivel de fișier, puteți utiliza tokens speciale precum <|fim_prefix|>, <|fim_suffix|>, și <|fim_middle|>. Iată un exemplu:

input_text = """<|fim_prefix|>def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
<|fim_suffix|>
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)<|fim_middle|>"""

model_inputs = tokenizer([input_text], return_tensors="pt").to(device)

generated_ids = model.generate(model_inputs.input_ids, max_new_tokens=512, do_sample=False)[0]

output_text = tokenizer.decode(generated_ids[len(model_inputs.input_ids[0]):], skip_special_tokens=True)

print(output_text)

f) Utilizarea vLLM pentru inferență în loturi

Pentru scenarii care necesită procesarea mai multor prompt-uri simultan, puteți utiliza vLLM pentru inferență în loturi. Iată un exemplu:

from transformers import AutoTokenizer
from vllm import LLM, SamplingParams

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-7B")

sampling_params = SamplingParams(temperature=0.7, top_p=0.8, repetition_penalty=1.05, max_tokens=1024)

llm = LLM(model="Qwen/Qwen2.5-Coder-7B")

prompt = "#write a quick sort algorithm.\ndef quick_sort("

outputs = llm.generate([prompt], sampling_params)

for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text
    print(f"Prompt: {prompt!r}, Generated text: {generated_text!r}")

g) Servire distribuită multi-GPU

Pentru scenarii care necesită o putere de procesare mai mare sau pentru a gestiona secvențe foarte lungi, puteți utiliza servirea distribuită multi-GPU. Iată cum să configurați acest lucru:

llm = LLM(model="Qwen/Qwen2.5-Coder-7B", tensor_parallel_size=4)

Acest cod va utiliza 4 GPU-uri în paralel pentru a rula modelul, permițând procesarea mai rapidă și gestionarea unor sarcini mai complexe.

4. Utilizarea modelului cu Ollama

Modelul poate fi instalat și prin Ollama, el fiind oferit în mai multe variante de cuantizare.

Varianta uzuală, qwen2.5-coder:7b are o dimensiune de aproximativ 5 GB.

În cele ce urmează vom face câteva teste de generare de cod folosind Visual Code Studio și extensia Continue configurată cu Ollama și acest model.

Pentru început vom cere generarea unui cod care afișează anii bisecți din perioada 2024-2048:

Generate python code to display the leap years in the period 2024-2048.

Codul generat este:

Here is a simple Python code that calculates and prints all the leap years between 2024 and 2048:

for year in range(2024, 2049):
    if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
        print(year)
This code works by iterating through the years from 2024 to 2048, checking if each one is a leap year (a year that is divisible by 4 but not divisible by 100, unless it's also divisible by 400), and then printing out the years that pass this te

Codul funcționează și condițiile sunt puse corect.

A doua cerință este este generarea unui cod pentru pentru problema melcului:

generate python code to resolve the next problem: a snail is at the bottom of a well of 20 m height. Each day the snails climbs 3 meters, but în the night it falls back by 2 meters. Compute the number of days it take the snail to get to the top of the well.

Codul generat este următorul:

Here's a Python script that calculates the number of days it takes for the snail to reach the top of the well:

def calculate_days(height, day_climb, night_fall):
    net_gain_per_day = day_climb - night_fall

    # If the net gain is more than or equal to the well height, we can just return 1 (since the snail will reach the top during that day)
    if net_gain_per_day >= height:
        return 1

    # Calculate the number of days it takes for the snail to be within one day's climb of the top
    days_to_reach_top = (height - day_climb) // net_gain_per_day + 1

    # In the last day the snail will reach the top during the day and won't fall back
    return days_to_reach_top + 1

well_height = 20
day_climb = 3
night_fall = 2

days_needed = calculate_days(well_height, day_climb, night_fall)
print(f"It takes {days_needed} days for the snail to reach the top of the well.")
This script defines a function calculate_days that computes how many days it takes for the snail to reach the top of the well given the well's height and the snail's daily climb and nightly fall. It then calculates and prints out the result.

In this case, since the net gain per day is only 1 meter (3 meters climbed during the day minus 2 meters fallen at night), it will take a total of 20 days for the snail to reach the top.

It takes 18 days for the snail to reach the top of the well.

Codul funcționează perfect.

Următorul task complex este problema clasică:

generate a python code for a game of life that runs in console.

Răspunsul modelului este:

The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It's played on an infinite two-dimensional grid of square cells, each of which can be in one of two possible states: "alive" or "dead".

For simplicity, let's create a finite version of the Game of Life that runs in the console and wraps around at the edges (toroidal boundary conditions). We'll use the curses library to handle screen output.

First, make sure you have the curses library installed. It comes pre-installed with Python on Unix-like systems. If you're using Windows, you might need to install it via pip:

pip install windows-curses
Now, here's a simple implementation of the Game of Life in console:

import curses
import time

def initialize_grid(rows, cols):
    return [[0 for _ in range(cols)] for _ in range(rows)]

def randomize_grid(grid, density=0.3):
    rows = len(grid)
    cols = len(grid[0])
    for i in range(rows):
        for j in range(cols):
            grid[i][j] = 1 if random.random() < density else 0
    return grid

def get_neighbors(grid, row, col):
    rows = len(grid)
    cols = len(grid[0])
    neighbors = 0
    for i in range(max(0, row-1), min(rows, row+2)):
        for j in range(max(0, col-1), min(cols, col+2)):
            if (i != row or j != col) and grid[i][j] == 1:
                neighbors += 1
    return neighbors

def next_state(grid):
    rows = len(grid)
    cols = len(grid[0])
    new_grid = initialize_grid(rows, cols)
    for i in range(rows):
        for j in range(cols):
            neighbors = get_neighbors(grid, i, j)
            if grid[i][j] == 1 and (neighbors < 2 or neighbors > 3):
                new_grid[i][j] = 0
            elif grid[i][j] == 0 and neighbors == 3:
                new_grid[i][j] = 1
            else:
                new_grid[i][j] = grid[i][j]
    return new_grid

def draw_grid(stdscr, grid):
    stdscr.clear()
    rows = len(grid)
    cols = len(grid[0])
    for i in range(rows):
        for j in range(cols):
            if grid[i][j] == 1:
                stdscr.addch(i, j, '#')
            else:
                stdscr.addch(i, j, ' ')
    stdscr.refresh()

def main(stdscr):
    curses.curs_set(0)  # Hide the cursor
    rows, cols = stdscr.getmaxyx()
    grid = initialize_grid(rows-2, cols-2)
    randomize_grid(grid)

    while True:
        draw_grid(stdscr, grid)
        time.sleep(0.5)
        grid = next_state(grid)

curses.wrapper(main)
Explanation:
Initialization: The initialize_grid function creates an empty grid of the specified size. The randomize_grid function populates the grid with a random distribution of live cells based on the given density.

Neighbor Calculation: The get_neighbors function counts the number of live neighbors for a given cell, considering toroidal boundary conditions.

Next State: The next_state function computes the next state of the grid according to the rules of the Game of Life:

Any live cell with fewer than two live neighbors dies.
Any live cell with two or three live neighbors lives on to the next generation.
Any live cell with more than three live neighbors dies.
Any dead cell with exactly three live neighbors becomes a live cell.
Drawing: The draw_grid function draws the current state of the grid in the console using the curses library.

Main Loop: The main function initializes the screen, randomizes the grid, and runs the main loop that updates the grid and redraws it every half-second.

Running the Game:
To run this script, save it to a file (e.g., game_of_life.py) and execute it in your terminal or command prompt:

python game_of_life.py
The game will start running in the console window. To exit, you can press Ctrl+C to interrupt the program.

This implementation is a basic version of the Game of Life. You can extend it by adding features like different initial patterns, saving and loading grid states, or improving the user interface.

Codul funcționează:

5. Concluzii

Punctele forte ale Qwen2.5-Coder nu se limitează doar la generarea de cod. Capacitatea sa de a înțelege structuri de cod la nivel de fișier și repozitoriu, combinată cu abilitățile robuste în matematică și sarcini generale, îl transformă într-un asistent virtual versatil pentru întregul proces de dezvoltare software.

Qwen2.5-Coder reprezintă un pas semnificativ înainte în domeniul asistenței AI pentru programare. Cu suportul său extins pentru multiple limbaje de programare, capacitatea de a înțelege și genera contexte lungi, și abilitățile avansate de raționament bazat pe cod, acest model se poziționează ca un instrument valoros pentru dezvoltatori de toate nivelurile.

Ușurința de utilizare și opțiunile flexibile de implementare, de la rularea locală până la servirea distribuită multi-GPU, fac din Qwen2.5-Coder o alegere atractivă atât pentru dezvoltatori individuali, cât și pentru organizații mari.

Cu toate acestea, este important să subliniem că, în ciuda capacităților sale avansate, Qwen2.5-Coder rămâne un instrument de asistență. Nu înlocuiește gândirea critică, creativitatea și experiența unui programator uman. În schimb, acest model AI ar trebui văzut ca un partener puternic care poate accelera procesul de dezvoltare, poate oferi idei noi și poate ajuta la depășirea blocajelor.

Pe măsură ce tehnologia AI continuă să evolueze, modele precum Qwen2.5-Coder vor juca fără îndoială un rol din ce în ce mai important în industria dezvoltării software. Ele au potențialul de a democratiza accesul la expertiza în programare, de a accelera inovația și de a permite dezvoltatorilor să se concentreze pe aspectele mai creative și strategice ale muncii lor.

În concluzie, Qwen2.5-Coder reprezintă un pas important către viitorul dezvoltării software asistate de AI. Cu capacitățile sale extinse și performanțele impresionante, acest model promite să redefinească modul în care programatorii interacționează cu codul și să deschidă noi posibilități în domeniul dezvoltării software.