Construya un asistente de codificación de IA de baja huella con un Devstral Mistral

En esta ultra luz Devstral Mistral Tutorial, se proporciona una guía amigable para Colab que está diseñada específicamente para los usuarios que enfrentan las limitaciones de espacio en disco. Ejecutar modelos de idiomas grandes como Mistral puede ser un desafío en entornos con almacenamiento y memoria limitados, pero este tutorial muestra cómo implementar el potente modelo Devstral-Small. Con cuantificación agresiva utilizando bitsandbytes, gestión de caché y generación de token eficiente, este tutorial lo guía a través de la construcción de un asistente liviano que sea rápido, interactivo y consciente del disco. Ya sea que esté depurando el código, escribiendo pequeñas herramientas o creando creadores de prototipos sobre la marcha, esta configuración asegura que obtenga el máximo rendimiento con una huella mínima.

!pip install -q kagglehub mistral-common bitsandbytes transformers --no-cache-dir
!pip install -q accelerate torch --no-cache-dir


import shutil
import os
import gc

El tutorial comienza instalando paquetes livianos esenciales como Kagglehub, Mistral-Common, Bitsandbytes y Transformers, asegurando que no se almacene no caché para minimizar el uso del disco. También incluye acelerar y antorcha para una carga e inferencia de modelos eficientes. Para optimizar aún más el espacio, cualquier caché o directorios temporales preexistentes se borra utilizando los módulos Sutil, OS y GC de Python.

def cleanup_cache():
   """Clean up unnecessary files to save disk space"""
   cache_dirs = ['/root/.cache', '/tmp/kagglehub']
   for cache_dir in cache_dirs:
       if os.path.exists(cache_dir):
           shutil.rmtree(cache_dir, ignore_errors=True)
   gc.collect()


cleanup_cache()
print("🧹 Disk space optimized!")

Para mantener una huella de disco mínima durante la ejecución, la función Cleanup_cache () se define para eliminar directorios de caché redundantes como /root/.cache y /tmp /kagglehub. Esta limpieza proactiva ayuda a liberar espacio antes y después de las operaciones clave. Una vez invocada, la función confirma que el espacio en disco ha sido optimizado, lo que refuerza el enfoque del tutorial en la eficiencia de los recursos.

import warnings
warnings.filterwarnings("ignore")


import torch
import kagglehub
from mistral_common.protocol.instruct.messages import UserMessage
from mistral_common.protocol.instruct.request import ChatCompletionRequest
from mistral_common.tokens.tokenizers.mistral import MistralTokenizer
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

Para garantizar una ejecución sin problemas sin distraer los mensajes de advertencia, suprimamos todas las advertencias de tiempo de ejecución utilizando el módulo de advertencias de Python. Luego importa bibliotecas esenciales para la interacción del modelo, incluida la antorcha para cálculos de tensor, kagglehub para transmitir el modelo y transformadores para cargar el LLM cuantificado. Las clases específicas de Mistral como Usermessage, ChatCompletionRequest y Mistaltokenizer también están empacadas para manejar la tokenización y el formateo de la solicitud adaptada a la arquitectura de Devstral.

class LightweightDevstral:
   def __init__(self):
       print("📦 Downloading model (streaming mode)...")
      
       self.model_path = kagglehub.model_download(
           'mistral-ai/devstral-small-2505/Transformers/devstral-small-2505/1',
           force_download=False 
       )
      
       quantization_config = BitsAndBytesConfig(
           bnb_4bit_compute_dtype=torch.float16,
           bnb_4bit_quant_type="nf4",
           bnb_4bit_use_double_quant=True,
           bnb_4bit_quant_storage=torch.uint8,
           load_in_4bit=True
       )
      
       print("⚡ Loading ultra-compressed model...")
       self.model = AutoModelForCausalLM.from_pretrained(
           self.model_path,
           torch_dtype=torch.float16,
           device_map="auto",
           quantization_config=quantization_config,
           low_cpu_mem_usage=True, 
           trust_remote_code=True
       )
      
       self.tokenizer = MistralTokenizer.from_file(f'{self.model_path}/tekken.json')
      
       cleanup_cache()
       print("✅ Lightweight assistant ready! (~2GB disk usage)")
  
   def generate(self, prompt, max_tokens=400): 
       """Memory-efficient generation"""
       tokenized = self.tokenizer.encode_chat_completion(
           ChatCompletionRequest(messages=[UserMessage(content=prompt)])
       )
      
       input_ids = torch.tensor([tokenized.tokens])
       if torch.cuda.is_available():
           input_ids = input_ids.to(self.model.device)
      
       with torch.inference_mode(): 
           output = self.model.generate(
               input_ids=input_ids,
               max_new_tokens=max_tokens,
               temperature=0.6,
               top_p=0.85,
               do_sample=True,
               pad_token_id=self.tokenizer.eos_token_id,
               use_cache=True 
           )[0]
      
       del input_ids
       torch.cuda.empty_cache() if torch.cuda.is_available() else None
      
       return self.tokenizer.decode(output[len(tokenized.tokens):])


print("🚀 Initializing lightweight AI assistant...")
assistant = LightweightDevstral()

Definimos la clase LightweightDevstral, el componente central del tutorial, que maneja la carga del modelo y la generación de texto de manera eficiente en recursos. Comienza transmitiendo el modelo Devstral-Small-2505 usando Kagglehub, evitando descargas redundantes. Luego, el modelo se carga con cuantización agresiva de 4 bits a través de BitsandbyTesConfig, reduciendo significativamente la memoria y el uso del disco al tiempo que permite la inferencia performadora. Un tokenizador personalizado se inicializa desde un archivo JSON local, y el caché se borra inmediatamente después. El método Generar emplea prácticas seguras a la memoria, como Torch.inference_mode () y vacía_cache (), para generar respuestas de manera eficiente, lo que hace que este asistente sea adecuado incluso para entornos con limitaciones de hardware estrictas.

def run_demo(title, prompt, emoji="🎯"):
   """Run a single demo with cleanup"""
   print(f"\n{emoji} {title}")
   print("-" * 50)
  
   result = assistant.generate(prompt, max_tokens=350)
   print(result)
  
   gc.collect()
   if torch.cuda.is_available():
       torch.cuda.empty_cache()


run_demo(
   "Quick Prime Finder",
   "Write a fast prime checker function `is_prime(n)` with explanation and test cases.",
   "🔢"
)


run_demo(
   "Debug This Code",
   """Fix this buggy function and explain the issues:
```python
def avg_positive(numbers):
   total = sum([n for n in numbers if n > 0])
   return total / len([n for n in numbers if n > 0])
```""",
   "🐛"
)


run_demo(
   "Text Tool Creator",
   "Create a simple `TextAnalyzer` class with word count, char count, and palindrome check methods.",
   "🛠️"
)

Aquí mostramos las habilidades de codificación del modelo a través de una suite de demostración compacta utilizando la función run_demo (). Cada demostración envía un mensaje al Asistente Devstral e imprime la respuesta generada, seguida inmediatamente por la limpieza de la memoria para evitar la acumulación en múltiples ejecuciones. Los ejemplos incluyen escribir una función eficiente de verificación primaria, depurar un fragmento de Python con defectos lógicos y construir una mini clase de textanalizador. Estas demostraciones destacan la utilidad del modelo como un asistente de codificación liviano y consciente de disco capaz de generación y explicación de código en tiempo real.

def quick_coding():
   """Lightweight interactive session"""
   print("\n🎮 QUICK CODING MODE")
   print("=" * 40)
   print("Enter short coding prompts (type 'exit' to quit)")
  
   session_count = 0
   max_sessions = 5 
  
   while session_count < max_sessions:
       prompt = input(f"\n[{session_count+1}/{max_sessions}] Your prompt: ")
      
       if prompt.lower() in ['exit', 'quit', '']:
           break
          
       try:
           result = assistant.generate(prompt, max_tokens=300)
           print("💡 Solution:")
           print(result[:500]) 
          
           gc.collect()
           if torch.cuda.is_available():
               torch.cuda.empty_cache()
              
       except Exception as e:
           print(f"❌ Error: {str(e)[:100]}...")
      
       session_count += 1
  
   print(f"\n✅ Session complete! Memory cleaned.")

Introducimos el modo de codificación rápida, una interfaz interactiva ligera que permite a los usuarios enviar indicaciones de codificación cortas directamente al Asistente Devstral. Diseñado para limitar el uso de la memoria, la interacción de la sesión de la sesión a cinco indicaciones, cada una seguida de una limpieza de memoria agresiva para garantizar la capacidad de respuesta continua en entornos de baja recursos. El asistente responde con sugerencias de código concisas y truncadas, lo que hace que este modo sea ideal para prototipos rápidos, depuración o exploración de conceptos de codificación sobre la marcha, todo sin abrumar el disco o la capacidad de memoria del cuaderno.

def check_disk_usage():
   """Monitor disk usage"""
   import subprocess
   try:
       result = subprocess.run(['df', '-h', '/'], capture_output=True, text=True)
       lines = result.stdout.split('\n')
       if len(lines) > 1:
           usage_line = lines[1].split()
           used = usage_line[2]
           available = usage_line[3]
           print(f"💾 Disk: {used} used, {available} available")
   except:
       print("💾 Disk usage check unavailable")




print("\n🎉 Tutorial Complete!")
cleanup_cache()
check_disk_usage()


print("\n💡 Space-Saving Tips:")
print("• Model uses ~2GB vs original ~7GB+")
print("• Automatic cache cleanup after each use") 
print("• Limited token generation to save memory")
print("• Use 'del assistant' when done to free ~2GB")
print("• Restart runtime if memory issues persist")

Finalmente, ofrecemos una rutina de limpieza y un útil monitor de uso de disco. Usando el comando DF -H a través del módulo de subprocesos de Python, muestra cuánto espacio en disco se usa y disponible, lo que confirma la naturaleza liviana del modelo. Después de volver a invocar Cleanup_Cache () para garantizar un residuo mínimo, el script concluye con un conjunto de consejos prácticos de ahorro de espacio.

En conclusión, ahora podemos aprovechar las capacidades del modelo Devstral de Mistral en entornos con restricciones espaciales como Google Colab, sin comprometer la usabilidad o la velocidad. El modelo se carga en un formato altamente comprimido, realiza una generación de texto eficiente y asegura que la memoria se borre rápidamente después de su uso. Con el modo de codificación interactivo y la suite de demostración incluida, los usuarios pueden probar sus ideas de manera rápida y perfecta.

Mira el Codos. Todo el crédito por esta investigación va a los investigadores de este proyecto. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro Subreddit de 100k+ ml y suscribirse a Nuestro boletín.