Cómo crear un entorno de desarrollo de Inteligencia Artificial en Linux con Python, Jupyter y modelos de código abierto

Idea central: un buen entorno de IA en Linux no empieza instalando paquetes al azar. Empieza con sistema actualizado, Python aislado, Jupyter bien configurado, dependencias controladas y modelos descargados de fuentes confiables.

sudo apt update
sudo apt full-upgrade -y

sudo apt install -y 
build-essential 
git 
curl 
wget 
ca-certificates 
python3 
python3-pip 
python3-venv 
python3-dev 
ffmpeg

sudo dnf update -y

sudo dnf groupinstall -y "Development Tools"
sudo dnf install -y 
git 
curl 
wget 
ca-certificates 
python3 
python3-pip 
python3-devel 
ffmpeg

mkdir -p ~/proyectos/ia-linux
cd ~/proyectos/ia-linux

python3 -m venv .venv
source .venv/bin/activate

python -m pip install --upgrade pip wheel setuptools

deactivate

source ~/proyectos/ia-linux/.venv/bin/activate

pip install jupyterlab ipykernel

python -m ipykernel install --user --name ia-linux --display-name "IA Linux Python"

jupyter lab --ip=127.0.0.1 --port=8888

Seguridad: no publiques Jupyter directamente en Internet. Si lo usarás en un servidor remoto, accede por VPN, túnel SSH o proxy seguro con autenticación.

pip install \
  numpy \
  pandas \
  matplotlib \
  scikit-learn \
  seaborn \
  scipy \
  notebook \
  tqdm

import numpy as np
import pandas as pd
import sklearn

print("NumPy:", np.**version**)
print("Pandas:", pd.**version**)
print("Scikit-learn:", sklearn.**version**)

pip install torch torchvision torchaudio

nvidia-smi

import torch

print("PyTorch:", torch.**version**)
print("CUDA disponible:", torch.cuda.is_available())

if torch.cuda.is_available():
print("GPU:", torch.cuda.get_device_name(0))

pip install transformers datasets accelerate sentencepiece huggingface_hub

from transformers import pipeline

clasificador = pipeline("sentiment-analysis")
resultado = clasificador("Linux es una gran plataforma para inteligencia artificial.")

print(resultado)

Licencias: no todos los modelos publicados como “abiertos” son software libre en sentido estricto. Antes de usar un modelo en producción, revisa licencia, restricciones comerciales, datos de entrenamiento y condiciones de redistribución.

hf auth login

hf download distilbert/distilbert-base-uncased

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

ollama run llama3.2

ollama list

pip install requests

import requests

respuesta = requests.post(
"http://localhost:11434/api/generate",
json={
"model": "llama3.2",
"prompt": "Explica en español qué es un entorno virtual de Python.",
"stream": False
}
)

print(respuesta.json()["response"])

ia-linux/
├── notebooks/
│   └── 01-pruebas-iniciales.ipynb
├── src/
│   └── app.py
├── data/
│   ├── raw/
│   └── processed/
├── models/
├── outputs/
├── requirements.txt
└── README.md

pip freeze > requirements.txt

python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

docker --version
docker compose version

1. Actualizar Linux y paquetes base.
2. Instalar Python, pip, venv, Git y herramientas de compilación.
3. Crear un entorno virtual por proyecto.
4. Instalar JupyterLab e ipykernel.
5. Instalar NumPy, pandas, scikit-learn y matplotlib.
6. Instalar PyTorch según CPU o GPU.
7. Instalar Transformers y Hugging Face Hub.
8. Probar un pipeline simple de IA.
9. Instalar Ollama para modelos locales.
10. Guardar dependencias en requirements.txt.
11. No exponer Jupyter ni APIs locales sin seguridad.
12. Revisar licencias de modelos antes de uso comercial.

• Instalar paquetes de IA en el Python del sistema.
• No usar entorno virtual por proyecto.
• Instalar PyTorch sin verificar CPU, CUDA o GPU.
• Mezclar versiones incompatibles de paquetes.
• No guardar requirements.txt.
• Descargar modelos sin revisar licencia.
• Exponer JupyterLab en Internet sin autenticación fuerte.
• No controlar el tamaño de modelos y cachés en disco.
• No separar datos, notebooks, código y resultados.

¿Linux es mejor para desarrollar inteligencia artificial?

Linux es una de las mejores opciones porque facilita Python, GPU, servidores, contenedores, automatización, Jupyter y despliegues reproducibles.

¿Necesito GPU para empezar?

No. Puedes aprender machine learning, Python, pandas, scikit-learn y Jupyter usando CPU. Para deep learning y modelos grandes, una GPU acelera mucho el trabajo.

¿JupyterLab reemplaza a un editor de código?

No completamente. JupyterLab es excelente para exploración, notebooks y experimentos. Para proyectos grandes conviene combinarlo con VS Code, PyCharm, Vim, Neovim u otro editor.

¿Puedo usar modelos de código abierto localmente?

Sí. Puedes usar Transformers, Ollama, llama.cpp y otros proyectos. Pero debes revisar la licencia de cada modelo porque “abierto” no siempre significa libre para todo uso.

¿Qué herramienta es mejor para empezar con LLM locales?

Ollama es una de las opciones más simples para empezar porque permite descargar y ejecutar modelos locales con pocos comandos.

¿Qué debo hacer antes de llevar esto a producción?

Separar ambientes, controlar dependencias, usar Docker o contenedores, proteger accesos, revisar licencias, monitorear recursos y documentar el proceso.

• Cómo montar un laboratorio de Inteligencia Artificial en Linux con herramientas open source
• Cómo construir un servidor de IA local utilizando Linux y modelos open source
• Ollama y la inteligencia artificial de código abierto: qué es y cómo instalarlo en Linux
• Comandos básicos para administrar un servidor Linux

Conclusión editorial

Linux ofrece la base más flexible para aprender y construir inteligencia artificial con software libre y modelos abiertos. Quien domine Python, Jupyter, entornos virtuales y ejecución local de modelos tendrá una ventaja clara para crear prototipos, automatizar tareas y desarrollar soluciones de IA más privadas, reproducibles y controlables.