Ghidul de promptare pentru Code Llama

Prezentare generală

Code Llama este o familie de modele de limbaj specializate în generarea și înțelegerea codului, dezvoltată de Meta AI. Acest ghid oferă strategii eficiente de promptare pentru a obține cel mai bun rezultat din aceste modele specializate în codare.

Caracteristici cheie

Specializarea în cod

• Antrenat pe miliarde de linii de cod
• Suport pentru multiple limbaje de programare
• Înțelegerea contextului și sintaxei
• Generarea de cod funcțional și optimizat

Variantele modelului

• Code Llama 7B: Pentru sarcini rapide și prototipare
• Code Llama 13B: Pentru sarcini complexe și debugging
• Code Llama 34B: Pentru sarcini avansate și optimizare

Strategii de promptare

Structurarea prompturilor

1. Contextul clar: Specifică limbajul și scopul
2. Cerințele specifice: Detaliază funcționalitatea dorită
3. Exemple concrete: Oferă exemple de input/output
4. Restricțiile: Specifică limitările și preferințele

Template-ul de bază

Limbajul: [specifică limbajul]
Scopul: [descrie ce vrei să realizezi]
Cerințele:
- [cerința 1]
- [cerința 2]
- [cerința 3]

Exemplu de input: [dacă este relevant]
Exemplu de output: [dacă este relevant]

Generează codul complet cu comentarii:

Exemple de promptare

Generarea de funcții

Prompt:

Limbajul: Python
Scopul: Creează o funcție pentru sortarea unei liste de numere
Cerințele:
- Funcția să accepte o listă ca parametru
- Să returneze lista sortată
- Să gestioneze cazurile de eroare
- Să includă documentația

Generează codul complet cu comentarii:

Output așteptat:

def sort_list(numbers):
    """
    Sortează o listă de numere în ordine crescătoare.
    
    Args:
        numbers (list): Lista de numere de sortat
        
    Returns:
        list: Lista sortată
        
    Raises:
        TypeError: Dacă inputul nu este o listă
        ValueError: Dacă lista conține elemente non-numerice
    """
    if not isinstance(numbers, list):
        raise TypeError("Inputul trebuie să fie o listă")
    
    if not all(isinstance(x, (int, float)) for x in numbers):
        raise ValueError("Toate elementele trebuie să fie numere")
    
    return sorted(numbers)

Debugging-ul codului

Prompt:

Limbajul: Python
Scopul: Debughează și corectează următorul cod
Problema: Codul nu funcționează corect

Codul cu probleme:
```python
def calculate_average(numbers):
    total = 0
    for i in range(len(numbers)):
        total += numbers[i]
    return total / len(numbers)

# Test
print(calculate_average([1, 2, 3, 4, 5]))

Identifică problemele și corectează codul:

### Optimizarea performanței
**Prompt**:

Limbajul: Python Scopul: Optimizează următorul cod pentru performanță Cerințele:

• Îmbunătățește viteza de execuție
• Reduce utilizarea memoriei
• Păstrează funcționalitatea

Codul original:

def find_duplicates(items):
    duplicates = []
    for i in range(len(items)):
        for j in range(i + 1, len(items)):
            if items[i] == items[j] and items[i] not in duplicates:
                duplicates.append(items[i])
    return duplicates

Generează versiunea optimizată:

## Tehnici avansate

### Few-shot learning
Oferă exemple concrete în prompt pentru a ghida modelul:

Limbajul: Python Scopul: Creează o funcție pentru validarea email-urilor

Exemple de funcții similare:

def validate_phone(phone):
    import re
    pattern = r'^\+?1?\d{9,15}$'
    return bool(re.match(pattern, phone))

Creează o funcție similară pentru validarea email-urilor:

### Chain-of-thought prompting
Încurajează modelul să gândească pas cu pas:

Limbajul: Python Scopul: Creează un algoritm de căutare binară Cerințele:

• Să gândești pas cu pas despre implementarea
• Să explici logica din spatele fiecărui pas
• Să generezi codul cu comentarii detaliate

Gândește-te pas cu pas despre cum să implementezi căutarea binară:

## Limitări și considerări

### Limitările tehnice
- **Dimensiunea contextului** poate limita codul complex
- **Limbajele de programare** pot avea suport diferit
- **Librările** pot fi limitate la cele din training

### Siguranța
- **Validarea codului** generat este esențială
- **Testarea** funcționalității înainte de implementare
- **Revizuirea** codului pentru vulnerabilități

## Învățăminte cheie

1. **Specificitatea** în prompturi pentru rezultate mai bune
2. **Exemplele concrete** ghidează modelul mai eficient
3. **Structurarea clară** a prompturilor îmbunătățește outputul
4. **Validarea și testarea** codului generat este crucială
5. **Few-shot learning** poate îmbunătăți semnificativ rezultatele
6. **Chain-of-thought** ajută la sarcini complexe
7. **Considerarea limitărilor** tehnice și de siguranță

## Referințe

- [Documentația oficială Code Llama](link-to-docs)
- [Modelele pe Hugging Face](link-to-hf)
- [Ghidul de promptare Meta](link-to-guide)

## Subiecte conexe

- [Generarea de cod](../applications/code-generation.md)
- [Promptarea eficientă](../prompting-techniques/effective-prompting.md)
- [Modelele specializate](../models/specialized-models.md)
- [Siguranța în generarea de cod](../applications/code-safety.md)