# CodeLlama

[Code Llama](https://huggingface.co/papers/2308.12950) es una familia especializada de modelos de lenguaje de gran tamaño basada en [Llama 2](./llama2) para tareas de programación. Está disponible en diferentes variantes: código general, específica de Python y una variante de seguimiento de instrucciones, todas en tamaños de 7B, 13B, 34B y 70B parámetros. Los modelos Code Llama pueden generar, explicar e incluso completar partes faltantes de tu código (conocido como "infilling"). También puede manejar contextos muy largos con una generación estable de hasta 100k tokens, a pesar de haber sido entrenado en secuencias de 16K tokens.

Puedes encontrar todos los puntos de control originales de Code Llama en la colección [Code Llama](https://huggingface.co/collections/meta-llama/code-llama-family-661da32d0a9d678b6f55b933).

> [!TIP]
> Haz clic en los modelos Code Llama en la barra lateral derecha para ver más ejemplos de cómo aplicar Code Llama a diferentes tareas de programación.

El siguiente ejemplo demuestra cómo generar código con [Pipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.Pipeline), o con [AutoModel](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoModel), y desde la línea de comandos.

```python
from transformers import pipeline

pipe = pipeline(
    "text-generation",
    model="meta-llama/CodeLlama-7b-hf",
    device_map=0
)

# basic code generation
result = pipe("# Function to calculate the factorial of a number\ndef factorial(n):", max_new_tokens=256)
print(result[0]['generated_text'])

# infilling
infill_result = pipe("def remove_non_ascii(s: str) -> str:\n    \"\"\" <FILL_ME>\n    return result", max_new_tokens=200)
print(infill_result[0]['generated_text'])
```

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("meta-llama/CodeLlama-7b-hf")
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/CodeLlama-7b-hf",
    device_map="auto",
    attn_implementation="sdpa"
)

# basic code generation
prompt = "# Function to calculate the factorial of a number\ndef factorial(n):"
input_ids = tokenizer(prompt, return_tensors="pt").to(model.device)

output = model.generate(
    **input_ids,
    max_new_tokens=256,
    cache_implementation="static"
)
print(tokenizer.decode(output[0], skip_special_tokens=True))

# infilling
infill_prompt = "def remove_non_ascii(s: str) -> str:\n    \"\"\" <FILL_ME>\n    return result"
input_ids = tokenizer(infill_prompt, return_tensors="pt").to(model.device)

filled_output = model.generate(**input_ids, max_new_tokens=200)
filled_text = tokenizer.decode(filled_output[0], skip_special_tokens=True)
print(filled_text)
```

La cuantización reduce la carga de memoria de los modelos grandes al representar los pesos con una precisión inferior. Consulte el resumen de [Cuantización](../quantization/overview) para conocer más backends de cuantización disponibles.

El ejemplo siguiente utiliza [bitsandbytes](../quantization/bitsandbytes) para cuantizar únicamente los pesos a 4 bits.

```python
# pip install bitsandbytes
import torch

from transformers import AutoModelForCausalLM, BitsAndBytesConfig, CodeLlamaTokenizer

bnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_quant_type="nf4", bnb_4bit_use_double_quant=True)
tokenizer = CodeLlamaTokenizer.from_pretrained("meta-llama/CodeLlama-34b-hf")
model = AutoModelForCausalLM.from_pretrained(
   "meta-llama/CodeLlama-34b-hf",
   device_map="auto",
   quantization_config=bnb_config
)

prompt = "# Write a Python function to check if a string is a palindrome\ndef is_palindrome(s):"
input_ids = tokenizer(prompt, return_tensors="pt").to(model.device)

output = model.generate(**input_ids, max_new_tokens=200, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

Utilice [AttentionMaskVisualizer](https://github.com/huggingface/transformers/blob/beb9b5b02246b9b7ee81ddf938f93f44cfeaad19/src/transformers/utils/attention_visualizer.py#L139) para comprender mejor qué tokens el modelo puede y no puede atender.

```python
from transformers.utils.attention_visualizer import AttentionMaskVisualizer

visualizer = AttentionMaskVisualizer("meta-llama/CodeLlama-7b-hf")
visualizer("""def func(a, b):
  return a + b""")
```

    

## Notas

- Infilling solo está disponible en los modelos base de 7B y 13B, y no en los modelos Python, Instruct, 34B o 70B.
- Use el token `<FILL_ME>` donde desee que se complete su entrada. El tokenizador divide este token para crear una cadena de entrada formateada que sigue el [patrón de entrenamiento original](https://github.com/facebookresearch/codellama/blob/cb51c14ec761370ba2e2bc351374a79265d0465e/llama/generation.py#L402). Esto es más robusto que preparar el patrón usted mismo.

    ```py
    from transformers import LlamaForCausalLM, CodeLlamaTokenizer

    tokenizer = CodeLlamaTokenizer.from_pretrained("meta-llama/CodeLlama-7b-hf")
    model = LlamaForCausalLM.from_pretrained("meta-llama/CodeLlama-7b-hf", device_map="auto")
    PROMPT = '''def remove_non_ascii(s: str) -> str:
        """ <FILL_ME>
        return result
    '''
    input_ids = tokenizer(PROMPT, return_tensors="pt").to(model.device)["input_ids"]
    generated_ids = model.generate(input_ids, max_new_tokens=128)

    filling = tokenizer.batch_decode(generated_ids[:, input_ids.shape[1]:], skip_special_tokens = True)[0]
    print(PROMPT.replace("<FILL_ME>", filling))
    ```

- Use `bfloat16` para el entrenamiento adicional o el ajuste fino y `float16` para la inferencia.
- El carácter `BOS` no se utiliza para el relleno al codificar el prefijo o el sufijo, sino solo al principio de cada indicación.
- El tokenizador es un modelo de codificación por pares de bytes basado en [SentencePiece](https://github.com/google/sentencepiece). Durante la decodificación, si el primer token es el inicio de la palabra (por ejemplo, “Banana”), el tokenizador no añade el prefijo de espacio a la cadena.

## CodeLlamaTokenizer[[transformers.CodeLlamaTokenizer]]

#### transformers.CodeLlamaTokenizer[[transformers.CodeLlamaTokenizer]]

```python
transformers.CodeLlamaTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, clean_up_tokenization_spaces = False, unk_token = '<unk>', bos_token = '<s>', eos_token = '</s>', prefix_token = '▁<PRE>', middle_token = '▁<MID>', suffix_token = '▁<SUF>', eot_token = '▁<EOT>', fill_token = '<FILL_ME>', additional_special_tokens = None, use_default_system_prompt: bool = False, add_prefix_space: bool | None = True, add_bos_token: bool = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/code_llama/tokenization_code_llama.py#L41)

**Parámetros:**

clean_up_tokenization_spaces (`str`, *opcional*, valor predeterminado `False`) : Si se deben limpiar los espacios tras la decodificación; la limpieza consiste en eliminar posibles artefactos, como espacios adicionales.

unk_token (`str`, *opcional*, valor predeterminado `"<unk>"`) : El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.

bos_token (`str`, *opcional*, valor predeterminado `"<s>"`) : El token de inicio de secuencia que se utilizó durante el preentrenamiento. Puede usarse como token de clasificador de secuencias.

eos_token (`str`, *opcional*, valor predeterminado `"</s>"`) : El token de fin de secuencia.

prefix_token (`str`, *opcional*, valor predeterminado `"▁<PRE>"`) : Token de prefijo utilizado para el relleno (infilling).

middle_token (`str`, *opcional*, valor predeterminado `"▁<MID>"`) : Token intermedio utilizado para el relleno.

suffix_token (`str`, *opcional*, valor predeterminado `"▁<SUF>"`) : Token de sufijo utilizado para el relleno.

eot_token (`str`, *opcional*, valor predeterminado `"▁<EOT>"`) : Token de fin de texto utilizado para el relleno (infilling).

fill_token (`str`, *opcional*, valor predeterminado `"<FILL_ME>"`) : El token utilizado para dividir la entrada entre el prefijo y el sufijo.

additional_special_tokens (`list[str]`, *opcional*) : Tokens especiales adicionales utilizados por el tokenizador.

add_bos_token (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir un token de inicio de secuencia al comienzo de las secuencias.

add_eos_token (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe añadir un token de fin de secuencia al final de las secuencias.

use_default_system_prompt (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe utilizar el prompt de sistema predeterminado para Llama.

add_prefix_space (`bool`, *opcional*) : Indica si se debe añadir un espacio inicial a la entrada. Esto permite tratar la palabra inicial como cualquier otra palabra.

vocab (`str`, `dict` o `list`, *opcional*) : Diccionario de vocabulario personalizado. Si no se proporciona, el vocabulario se carga desde vocab_file.

merges (`str` o `list`, *opcional*) : Lista de fusiones personalizada. Si no se proporciona, las fusiones se cargan desde merges_file.

vocab_file (`str`, *opcional*) : archivo [SentencePiece](https://github.com/google/sentencepiece) (generalmente con extensión .model) que contiene el vocabulario necesario para instanciar un tokenizador.

Construye un tokenizador de Llama. Basado en Byte-Pair-Encoding a nivel de bytes.

Esto utiliza notablemente ByteFallback y no normalización.

```python
>>> from transformers import CodeLlamaTokenizer

>>> tokenizer = CodeLlamaTokenizer.from_pretrained("hf-internal-testing/llama-tokenizer")
>>> tokenizer.encode("Hello this is a test")
[1, 15043, 445, 338, 263, 1243]
```

Si deseas cambiar el `bos_token` o el `eos_token`, asegúrate de especificarlos al inicializar el modelo, o llama a `tokenizer.update_post_processor()` para garantizar que el post-procesamiento se realice correctamente (de lo contrario, los valores del primer token y del token final de una secuencia codificada no serán correctos). Para más detalles, consulta la documentación de [post-processors] (https://huggingface.co/docs/tokenizers/api/post-processors).

Este tokenizador hereda de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.TokenizersBackend), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos. La configuración predeterminada coincide con la de [meta-llama/CodeLlama-7b-Instruct-hf](https://huggingface.co/meta-llama/CodeLlama-7b-Instruct-hf/blob/main/tokenizer_config.json), que admite el relleno de prompts.

#### get_special_tokens_mask[[transformers.CodeLlamaTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1337)

**Parámetros:**

token_ids_0 : Lista de IDs de la secuencia (posiblemente ya formateada).

token_ids_1 : No se utiliza cuando `already_has_special_tokens=True`. En ese caso, debe ser None.

already_has_special_tokens : Si la secuencia ya está formateada con tokens especiales.

**Devuelve:** Una lista de enteros en el rango [0, 1]

1 para un token especial, 0 para un token de secuencia.

Obtener los ids de secuencia de una lista de tokens a la que no se le han añadido tokens especiales.

Para los tokenizadores rápidos, los collators de datos llaman a esta función con `already_has_special_tokens=True` para construir una máscara sobre una secuencia ya formateada. En ese caso, calculamos la máscara comprobando la pertenencia a `all_special_ids`.

#### update_post_processor[[transformers.CodeLlamaTokenizer.update_post_processor]]

```python
update_post_processor()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L628)

Actualiza el procesador posterior subyacente con el `bos_token` y el `eos_token` actuales.

#### save_vocabulary[[transformers.CodeLlamaTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L547)

## CodeLlamaTokenizerFast[[transformers.CodeLlamaTokenizer]]

#### transformers.CodeLlamaTokenizer[[transformers.CodeLlamaTokenizer]]

```python
transformers.CodeLlamaTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, clean_up_tokenization_spaces = False, unk_token = '<unk>', bos_token = '<s>', eos_token = '</s>', prefix_token = '▁<PRE>', middle_token = '▁<MID>', suffix_token = '▁<SUF>', eot_token = '▁<EOT>', fill_token = '<FILL_ME>', additional_special_tokens = None, use_default_system_prompt: bool = False, add_prefix_space: bool | None = True, add_bos_token: bool = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/code_llama/tokenization_code_llama.py#L41)

**Parámetros:**

clean_up_tokenization_spaces (`str`, *opcional*, valor predeterminado `False`) : Si se deben limpiar los espacios tras la decodificación; la limpieza consiste en eliminar posibles artefactos, como espacios adicionales.

unk_token (`str`, *opcional*, valor predeterminado `"<unk>"`) : El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.

bos_token (`str`, *opcional*, valor predeterminado `"<s>"`) : El token de inicio de secuencia que se utilizó durante el preentrenamiento. Puede usarse como token de clasificador de secuencias.

eos_token (`str`, *opcional*, valor predeterminado `"</s>"`) : El token de fin de secuencia.

prefix_token (`str`, *opcional*, valor predeterminado `"▁<PRE>"`) : Token de prefijo utilizado para el relleno (infilling).

middle_token (`str`, *opcional*, valor predeterminado `"▁<MID>"`) : Token intermedio utilizado para el relleno.

suffix_token (`str`, *opcional*, valor predeterminado `"▁<SUF>"`) : Token de sufijo utilizado para el relleno.

eot_token (`str`, *opcional*, valor predeterminado `"▁<EOT>"`) : Token de fin de texto utilizado para el relleno (infilling).

fill_token (`str`, *opcional*, valor predeterminado `"<FILL_ME>"`) : El token utilizado para dividir la entrada entre el prefijo y el sufijo.

additional_special_tokens (`list[str]`, *opcional*) : Tokens especiales adicionales utilizados por el tokenizador.

add_bos_token (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir un token de inicio de secuencia al comienzo de las secuencias.

add_eos_token (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe añadir un token de fin de secuencia al final de las secuencias.

use_default_system_prompt (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe utilizar el prompt de sistema predeterminado para Llama.

add_prefix_space (`bool`, *opcional*) : Indica si se debe añadir un espacio inicial a la entrada. Esto permite tratar la palabra inicial como cualquier otra palabra.

vocab (`str`, `dict` o `list`, *opcional*) : Diccionario de vocabulario personalizado. Si no se proporciona, el vocabulario se carga desde vocab_file.

merges (`str` o `list`, *opcional*) : Lista de fusiones personalizada. Si no se proporciona, las fusiones se cargan desde merges_file.

vocab_file (`str`, *opcional*) : archivo [SentencePiece](https://github.com/google/sentencepiece) (generalmente con extensión .model) que contiene el vocabulario necesario para instanciar un tokenizador.

Construye un tokenizador de Llama. Basado en Byte-Pair-Encoding a nivel de bytes.

Esto utiliza notablemente ByteFallback y no normalización.

```python
>>> from transformers import CodeLlamaTokenizer

>>> tokenizer = CodeLlamaTokenizer.from_pretrained("hf-internal-testing/llama-tokenizer")
>>> tokenizer.encode("Hello this is a test")
[1, 15043, 445, 338, 263, 1243]
```

Si deseas cambiar el `bos_token` o el `eos_token`, asegúrate de especificarlos al inicializar el modelo, o llama a `tokenizer.update_post_processor()` para garantizar que el post-procesamiento se realice correctamente (de lo contrario, los valores del primer token y del token final de una secuencia codificada no serán correctos). Para más detalles, consulta la documentación de [post-processors] (https://huggingface.co/docs/tokenizers/api/post-processors).

Este tokenizador hereda de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.TokenizersBackend), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos. La configuración predeterminada coincide con la de [meta-llama/CodeLlama-7b-Instruct-hf](https://huggingface.co/meta-llama/CodeLlama-7b-Instruct-hf/blob/main/tokenizer_config.json), que admite el relleno de prompts.

#### set_infilling_processor[[transformers.CodeLlamaTokenizer.set_infilling_processor]]

```python
set_infilling_processor(reset, suffix_first = False, add_special_tokens = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/code_llama/tokenization_code_llama.py#L229)

Actualiza el normalizador para asegurarse de que se respete el formato de prompt para `infilling`. El formato de infilling es el siguiente: si suffix_first "  {suf}  {pre}" else: "  {pre} {suf} "

Si `reset` se establece en `True`, `normalizer` y `post_processor` se restablecen a su comportamiento "normal", que consiste en añadir un espacio de prefijo para el normalizador y añadir un `bos_token` al texto de entrada para el `post_processor`.

