CodeLlama

Genera, completa y explica código con CodeLlama en Clore.ai

¡Alternativas más nuevas! Para tareas de codificación, considera Qwen2.5-Coder (32B, generación de código de última generación) o DeepSeek-R1 (razonamiento + codificación). CodeLlama sigue siendo útil para despliegues ligeros.

Genera, completa y explica código con CodeLlama de Meta.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

Alquilar en CLORE.AI

Visita CLORE.AI Marketplace
Filtrar por tipo de GPU, VRAM y precio
Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)
Configura tu pedido:
- Selecciona imagen Docker
- Establece puertos (TCP para SSH, HTTP para interfaces web)
- Agrega variables de entorno si es necesario
- Introduce el comando de inicio
Selecciona pago: CLORE, BTC, o USDT/USDC
Crea el pedido y espera el despliegue

Accede a tu servidor

Encuentra los detalles de conexión en Mis Pedidos
Interfaces web: Usa la URL del puerto HTTP
SSH: ssh -p <port> root@<proxy-address>

Variantes de modelo

Modelo

Tamaño

VRAM

Mejor para

CodeLlama-7B

8GB

Completado rápido

CodeLlama-13B

13B

16GB

Equilibrado

CodeLlama-34B

34B

40GB

Mejor calidad

CodeLlama-70B

70B

80GB+

Calidad máxima

Variantes

Base: Completado de código
Instruct: Seguir instrucciones
Python: Especializado en Python

Despliegue rápido

Imagen Docker:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime

Puertos:

22/tcp
8000/http

Comando:

pip install vllm && \
python -m vllm.entrypoints.openai.api_server \
    --model codellama/CodeLlama-7b-Instruct-hf \
    --port 8000

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

Ir a Mis Pedidos página
Haz clic en tu pedido
Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Instalación

Usando Ollama


# Instalar Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Ejecutar CodeLlama
ollama run codellama

# Ejecutar variante de Python
ollama run codellama:python

Usando Transformers

pip install transformers accelerate

Completado de código

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-hf"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Completado de código
code = """
def fibonacci(n):
    '''Calcula el enésimo número de Fibonacci'''
"""

inputs = tokenizer(code, return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=200,
    temperature=0.2,
    do_sample=True
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Modelo Instruct

Para seguir instrucciones de codificación:

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Instruct-hf"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

prompt = """[INST] Escribe una función Python que:
1. Tome una lista de números
2. Elimine duplicados
3. Ordene en orden descendente
4. Devuelva los 5 primeros elementos
[/INST]"""

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=500,
    temperature=0.2
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Fill-in-the-Middle (FIM)


# CodeLlama admite FIM para inserción de código
prefix = """def calculate_area(shape, dimensions):
    if shape == "circle":
        radius = dimensions[0]
"""

suffix = """
    elif shape == "rectangle":
        length, width = dimensions
        return length * width
    return None
"""

# Usa tokens especiales para FIM
prompt = f"<PRE> {prefix} <SUF>{suffix} <MID>"

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=100)

Modelo especializado en Python

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Python-hf"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Completado específico de Python
code = """
import pandas as pd
import numpy as np

def analyze_sales_data(df):
    '''Analiza datos de ventas y devuelve métricas clave'''
"""

inputs = tokenizer(code, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=300)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Servidor vLLM

python -m vllm.entrypoints.openai.api_server \
    --model codellama/CodeLlama-13b-Instruct-hf \
    --dtype float16 \
    --max-model-len 8192

Uso de la API

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="x")

response = client.chat.completions.create(
    model="codellama/CodeLlama-13b-Instruct-hf",
    messages=[
        {"role": "user", "content": "Escribe un endpoint FastAPI para autenticación de usuarios"}
    ],
    temperature=0.2,
    max_tokens=1000
)

print(response.choices[0].message.content)

Explicación de código

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

prompt = f"[INST] Explica este código paso a paso:\n\n{code_to_explain}\n[/INST]"

Corrección de errores

buggy_code = """
def reverse_string(s):
    result = ""
    for i in range(len(s)):
        result += s[i]
    return result
"""

prompt = f"""[INST] Encuentra y corrige el error en este código. La función debería invertir una cadena:

{buggy_code}
[/INST]"""

Traducción de código

python_code = """
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)
"""

prompt = f"""[INST] Convierte este código Python a JavaScript:

{python_code}
[/INST]"""

Interfaz Gradio

import gradio as gr
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Instruct-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

def generate_code(instruction, temperature, max_tokens):
    prompt = f"[INST] {instruction} [/INST]"
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

    outputs = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        temperature=temperature,
        do_sample=True
    )

    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response.split("[/INST]")[-1].strip()

demo = gr.Interface(
    fn=generate_code,
    inputs=[
        gr.Textbox(label="Instruction", lines=5, placeholder="Escribe una función Python que..."),
        gr.Slider(0.1, 1.0, value=0.2, label="Temperature"),
        gr.Slider(100, 2000, value=500, step=100, label="Max Tokens")
    ],
    outputs=gr.Code(language="python", label="Generated Code"),
    title="Generador de código CodeLlama"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Procesamiento por lotes

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Instruct-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

tasks = [
    "Escribe una función para validar direcciones de correo electrónico",
    "Crea una clase para gestionar un carrito de compras",
    "Escribe una función para analizar JSON desde una URL",
    "Crea un decorador para medir el tiempo de ejecución de una función",
    "Escribe una función para generar contraseñas aleatorias"
]

for task in tasks:
    prompt = f"[INST] {task} [/INST]"
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

    outputs = model.generate(
        **inputs,
        max_new_tokens=500,
        temperature=0.2
    )

    result = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print(f"\n=== {task} ===")
    print(result.split("[/INST]")[-1].strip())

Usar con Continue (VSCode)

Configurar la extensión Continue:

{
  "models": [
    {
      "title": "CodeLlama",
      "provider": "ollama",
      "model": "codellama:7b-instruct"
    }
  ],
  "tabAutocompleteModel": {
    "title": "CodeLlama",
    "provider": "ollama",
    "model": "codellama:7b-code"
  }
}

Rendimiento

Modelo

GPU

Tokens/seg

CodeLlama-7B

RTX 3090

~90

CodeLlama-7B

RTX 4090

~130

CodeLlama-13B

RTX 4090

~70

CodeLlama-34B

A100

~50

Solución de problemas

Mala calidad de código

Temperatura más baja (0.1-0.3)
Usa la variante Instruct
Modelo más grande si es posible

Salida incompleta

Aumenta max_new_tokens
Revisa la longitud del contexto

Generación lenta

Usa vLLM
Cuantiza el modelo
Usa una variante más pequeña

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU

Tarifa por hora

Tarifa diaria

Sesión de 4 horas

RTX 3060

~$0.03

~$0.70

~$0.12

RTX 3090

~$0.06

~$1.50

~$0.25

RTX 4090

~$0.10

~$2.30

~$0.40

A100 40GB

~$0.17

~$4.00

~$0.70

A100 80GB

~$0.25

~$6.00

~$1.00

Los precios varían según el proveedor y la demanda. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)
Paga con CLORE tokens
Compara precios entre diferentes proveedores

Próximos pasos

Open Interpreter - Ejecutar código
Inferencia vLLM - Servicio en producción
Mistral/Mixtral - Modelos alternativos

AnteriorQwen2.5 SiguienteGemma 2

Última actualización hace 1 día

¿Te fue útil?

hashtagAlquilar en CLORE.AI

hashtagAccede a tu servidor

hashtagVariantes de modelo

hashtagVariantes

hashtagDespliegue rápido

hashtagAccediendo a tu servicio

hashtagInstalación

hashtagUsando Ollama

hashtagUsando Transformers

hashtagCompletado de código

hashtagModelo Instruct

hashtagFill-in-the-Middle (FIM)

hashtagModelo especializado en Python

hashtagServidor vLLM

hashtagUso de la API

hashtagExplicación de código

hashtagCorrección de errores

hashtagTraducción de código

hashtagInterfaz Gradio

hashtagProcesamiento por lotes

hashtagUsar con Continue (VSCode)

hashtagRendimiento

hashtagSolución de problemas

hashtagMala calidad de código

hashtagSalida incompleta

hashtagGeneración lenta

hashtagEstimación de costos

hashtagPróximos pasos

Alquilar en CLORE.AI

Accede a tu servidor

Variantes de modelo

Variantes

Despliegue rápido

Accediendo a tu servicio

Instalación

Usando Ollama

Usando Transformers

Completado de código

Modelo Instruct

Fill-in-the-Middle (FIM)

Modelo especializado en Python

Servidor vLLM

Uso de la API

Explicación de código

Corrección de errores

Traducción de código

Interfaz Gradio

Procesamiento por lotes

Usar con Continue (VSCode)

Rendimiento

Solución de problemas

Mala calidad de código

Salida incompleta

Generación lenta

Estimación de costos

Próximos pasos