Desplegando un modelo de IA local de Geología en Windows

El ecosistema de inteligencia artificial abierta cuenta con modelos especializados en geociencias (como la familia GeoLlama o K2-GEO), entrenados con corpus masivos de literatura sobre petrología, geoquímica, tectónica y mapas del USGS y la EGU. Aunque estos modelos suelen publicarse en Hugging Face en formato nativo de PyTorch (.safetensors), convertirlos al formato GGUF permite ejecutarlos al 100% en la VRAM de tu GPU mediante llama.cpp.

Con los 16 GB de VRAM GDDR7 de la NVIDIA RTX 5070 Ti (arquitectura Blackwell) y los binarios de llama.cpp ya compilados con soporte CUDA, este es el flujo de trabajo paso a paso para clonar, convertir, cuantizar y ejecutar un modelo de 8B parámetros en tu entorno local.

Paso 1: Clonar el modelo especializado desde Hugging Face

Asegúrate de tener instalado git-lfs (Large File Storage) para descargar correctamente los pesos pesados del repositorio. Doy por hecho que tienes instalado llama.cp en el directorio C:\llama\models y que tienes una cuenta en huggingface:

# Activar la extensión Git LFS en la sesión
git lfs install

# Crear un directorio para almacenar los modelos locales
cd c:\llama\modelos

# Clonar el repositorio del modelo especializado en geología
git clone https://huggingface.co/itpossible/JiuZhou-Instruct-v0.2 models/JiuZhou-Instruct-v0.2

cd ..

Paso 2: Convertir los pesos de PyTorch (safetensors) a formato GGUF

llama.cpp incluye un script oficial en Python (convert_hf_to_gguf.py) que unifica los fragmentos del repositorio clonado en un único archivo binario .gguf en precisión flotante original (FP16/BF16).

# Instalar los paquetes Python requeridos para el script de conversión
pip install -r requirements.txt

# Convertir el repositorio clonado a un único binario GGUF en FP16
python convert_hf_to_gguf.py models/JiuZhou-Instruct-v0.2 --outfile models/jiuzhou-instruct-v0.2-fp16.gguf

Paso 3: Cuantizar el modelo a Q4_K_M para optimizar la VRAM

Aunque un modelo de 8B en FP16 ocupa unos 16 GB y cabría justo en la RTX 5070 Ti, cuantizarlo a Q4_K_M (formato híbrido de 4 bits con precisión media en atención) reduce el peso del archivo a ~5.2 GB. Esto deja más de 10 GB de VRAM completamente libres para alojar contextos extensos de lectura (artículos largos, tablas de óxidos o normas CIPW) sin saturar la memoria.

# Ejecutar la utilidad de cuantización compilada en llama.cpp
./llama-quantize models/jiuzhou-instruct-v0.2-fp16.gguf models/jiuzhou-instruct-v0.2-Q4_K_M.gguf Q4_K_M

(Opcional) Si prefieres descartar el archivo intermedio en FP16 para recuperar espacio en disco:

rm models/jiuzhou-instruct-v0.2-Q4_K_M.gguf

Paso 4: Ejecutar la inferencia interactiva en la RTX 5070 Ti

Utiliza el binario de consola (llama-cli) forzando la delegación de todas las capas del modelo a la GPU mediante el parámetro -ngl 99 (number of GPU layers).

./build/bin/llama-cli \
  -m models/jiuzhou-instruct-v0.2-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --temp 0.2 \
  -p "Sistema: Eres un asistente experto en petrología ígnea, geoquímica de elementos mayores y geología estructural.\nUsuario: Describe la secuencia de cristalización de un magma basáltico alcalino y los minerales esperados en la norma CIPW.\nAsistente:"

Explicación de parámetros clave:

• -ngl 99: Carga el 100% de las capas directamente en los Tensor Cores de la arquitectura Blackwell.
• -c 8192: Asigna una ventana de contexto de 8.192 tokens en el KV-cache de la VRAM.
• --temp 0.2: Ajusta la temperatura a valores bajos para mantener alta precisión técnica e infalibilidad en terminología geológica.

Paso 5 (Opcional): Levantar un servidor API local compatible con OpenAI

Si deseas conectar el modelo a una interfaz web (como Open WebUI), un script de Python o un flujo en VS Code:

./build/bin/llama-server \
  -m models/jiuzhou-instruct-v0.2-Q4_K_M.gguf \
  --port 8080 \
  -ngl 99 \
  -c 8192

El servidor quedará a la escucha en http://localhost:8080/v1/chat/completions, permitiéndote enviar consultas en formato JSON estándar. En este caso podremos usar interfaces como Open WebUI.

Si quieres automatizar todo el proceso aquí te dejo un script de Powershell que lo hace, eso si, revisa las rutas antes de ejecutarlo para ajustarlo a tu instalación.

==============================================================================

Script: setup_geology_model.ps1

Descripción: Automatiza la descarga, conversión a GGUF, cuantización,

limpieza y ejecución de un modelo especializado en geología.

GPU Objetivo: NVIDIA RTX 5070 Ti 16 GB (Arquitectura Blackwell)

Sistema Operativo: Windows (PowerShell)

==============================================================================

$ErrorActionPreference = "Stop"

Configuración de rutas y variables

$MODEL_REPO = "https://huggingface.co/itpossible/JiuZhou-Instruct-v0.2"
$MODEL_DIR = "models\JiuZhou-Instruct-v0.2"
$FP16_GGUF = "models\jiuzhou-instruct-v0.2-fp16.gguf"
$FINAL_GGUF = "models\jiuzhou-instruct-v0.2-Q4_K_M.gguf"
$QUANT_TYPE = "Q4_K_M"

Rutas de binarios de llama.cpp compilados para Windows con CUDA

Admite tanto la estructura de compilación CMake (build\bin\Release) como ejecutable en raíz

$QUANT_BIN = if (Test-Path "build\bin\Release\llama-quantize.exe") { "build\bin\Release\llama-quantize.exe" } elseif (Test-Path "build\bin\llama-quantize.exe") { "build\bin\llama-quantize.exe" } else { "llama-quantize.exe" }
$CLI_BIN   = if (Test-Path "build\bin\Release\llama-cli.exe") { "build\bin\Release\llama-cli.exe" } elseif (Test-Path "build\bin\llama-cli.exe") { "build\bin\llama-cli.exe" } else { "llama-cli.exe" }
$CONVERT_SCRIPT = "convert_hf_to_gguf.py"

Write-Host "=== [1/5] Verificando prerrequisitos y herramientas ===" -ForegroundColor Cyan

if (-not (Get-Command "git" -ErrorAction SilentlyContinue)) {
Write-Error "Error: 'git' no está instalado o no se encuentra en el PATH."
exit 1
}

if (-not (Get-Command "git-lfs" -ErrorAction SilentlyContinue)) {
Write-Error "Error: 'git-lfs' no está instalado. Ejecuta 'git lfs install' primero."
exit 1
}

if (-not (Test-Path $CONVERT_SCRIPT)) {
Write-Error "Error: El script '$CONVERT_SCRIPT' no existe en el directorio actual. Asegúrate de ejecutar este script desde la raíz de llama.cpp."
exit 1
}

if (-not (Test-Path $QUANT_BIN)) {
Write-Error "Error: No se encontró el binario de cuantización '$QUANT_BIN'. Verifica la compilación CUDA de llama.cpp."
exit 1
}

Inicializar Git LFS

git lfs install | Out-Null

Write-Host "=== [2/5] Descargando modelo geológico desde Hugging Face ===" -ForegroundColor Cyan
if (Test-Path $MODEL_DIR) {
Write-Host "El directorio '$MODEL_DIR' ya existe. Omitiendo clonación..." -ForegroundColor Yellow
} else {
if (-not (Test-Path "models")) { New-Item -ItemType Directory -Path "models" | Out-Null }
Write-Host "Clonando $MODEL_REPO en$MODEL_DIR..."
git clone $MODEL_REPO$MODEL_DIR
}

Write-Host "=== [3/5] Convirtiendo safetensors a GGUF (FP16) ===" -ForegroundColor Cyan
if (Test-Path $FP16_GGUF) {
Write-Host "El archivo FP16 '$FP16_GGUF' ya existe. Omitiendo conversión..." -ForegroundColor Yellow
} else {
Write-Host "Instalando dependencias de Python necesarias..."
pip install -q -r requirements.txt

Write-Host "Ejecutando script de conversión a GGUF..."
python $CONVERT_SCRIPT $MODEL_DIR --outfile$FP16_GGUF


}

Write-Host "=== [4/5] Cuantizando modelo a $QUANT_TYPE ===" -ForegroundColor Cyan
if (Test-Path $FINAL_GGUF) {
Write-Host "El modelo cuantizado '$FINAL_GGUF' ya existe. Omitiendo cuantización..." -ForegroundColor Yellow
} else {
Write-Host "Cuantizando $FP16_GGUF -> $FINAL_GGUF ($QUANT_TYPE)..."
& $QUANT_BIN$FP16_GGUF $FINAL_GGUF$QUANT_TYPE
}

Write-Host "=== [5/5] Limpiando archivos intermedios ===" -ForegroundColor Cyan
Write-Host "Eliminando repositorio raw de Hugging Face y binario FP16 para liberar espacio..."
if (Test-Path $MODEL_DIR) { Remove-Item -Recurse -Force$MODEL_DIR }
if (Test-Path $FP16_GGUF) { Remove-Item -Force$FP16_GGUF }
Write-Host "Limpieza completada exitosamente." -ForegroundColor Green

Write-Host "" -ForegroundColor Green
Write-Host " ¡Despliegue finalizado! Modelo listo en: $FINAL_GGUF" -ForegroundColor Green
Write-Host "" -ForegroundColor Green

Pregunta opcional para iniciar interacción inmediata

$response = Read-Host "¿Deseas iniciar una sesión interactiva en la GPU (RTX 5070 Ti) ahora mismo? (s/N)"
if ($response -match "^[Ss]$") {
Write-Host "Iniciando llama-cli.exe con offload completo a VRAM (-ngl 99)..." -ForegroundColor Cyan
& $CLI_BIN -m $FINAL_GGUF
-ngl 99 -c 8192
--temp 0.2 `
-p "Sistema: Eres un asistente experto en geología, geoquímica y petrología.\nUsuario: Explica las series de reacción de Bowen y el orden de cristalización en un magma basáltico.\nAsistente:"
}

Instrucciones de uso en Windows:

1. Guarda el archivo setup_geology_model.ps1 en el directorio principal de tu instalación de llama.cpp.
2. Abre PowerShell como administrador si necesitas cambiar las políticas de ejecución de scripts en Windows (sólo la primera vez):

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

3. Ejecuta el script:

.\setup_geology_model.ps1