Python para Inteligencia Artificial: Guía para Principiantes [2026]

1# Descarga desde https://www.python.org/downloads/
2# Ejecuta el instalador
3 
4# Verifica instalación
5python --version

1# Con Homebrew (recomendado)
2brew install python3
3 
4# Verifica
5python3 --version

1sudo apt update
2sudo apt install python3 python3-pip
3 
4python3 --version

1# Crear entorno
2python -m venv entorno_ia
3 
4# Activar entorno
5# En Windows:
6entorno_ia\Scripts\activate
7 
8# En macOS/Linux:
9source entorno_ia/bin/activate
10 
11# Deberías ver (entorno_ia) al inicio de tu terminal

1# Actualizar pip
2pip install --upgrade pip
3 
4# Verificar
5pip --version

1mkdir proyecto_ia
2cd proyecto_ia
3 
4mkdir data
5mkdir modelos
6mkdir scripts
7mkdir notebooks
8 
9touch requirements.txt
10touch main.py

1pip install numpy

1import numpy as np
2 
3# Crear arrays
4numeros = np.array([1, 2, 3, 4, 5])
5print(numeros)  # [1 2 3 4 5]
6 
7# Operaciones
8print(numeros * 2)  # [2 4 6 8 10]
9print(numeros.mean())  # 3.0
10print(numeros.sum())  # 15
11 
12# Matrices (imágenes, datos)
13matriz = np.array([[1, 2], [3, 4]])
14print(matriz.shape)  # (2, 2)

1pip install pandas

1import pandas as pd
2 
3# Crear dataframe desde CSV
4df = pd.read_csv('datos.csv')
5print(df.head())  # Primeras 5 filas
6 
7# Explorar datos
8print(df.shape)  # Dimensiones
9print(df.info())  # Tipos de datos
10print(df.describe())  # Estadísticas
11 
12# Limpieza básica
13df = df.dropna()  # Remover valores nulos
14df = df.drop_duplicates()  # Remover duplicados
15 
16# Filtros
17clientes_premium = df[df['gasto'] > 1000]

1pip install scikit-learn

1from sklearn.model_selection import train_test_split
2from sklearn.ensemble import RandomForestClassifier
3from sklearn.metrics import accuracy_score
4 
5# Dividir datos en entrenamiento y prueba
6X_train, X_test, y_train, y_test = train_test_split(
7    X, y, test_size=0.2, random_state=42
8)
9 
10# Crear y entrenar modelo
11modelo = RandomForestClassifier(n_estimators=100)
12modelo.fit(X_train, y_train)
13 
14# Hacer predicciones
15predicciones = modelo.predict(X_test)
16 
17# Evaluar
18precisión = accuracy_score(y_test, predicciones)
19print(f"Precisión: {precisión:.2%}")

1pip install tensorflow

1from tensorflow import keras
2from tensorflow.keras import layers
3 
4# Crear red neuronal simple
5modelo = keras.Sequential([
6    layers.Dense(128, activation='relu', input_shape=(28, 28)),
7    layers.Dropout(0.2),
8    layers.Dense(64, activation='relu'),
9    layers.Dropout(0.2),
10    layers.Dense(10, activation='softmax')  # 10 clases
11])
12 
13# Compilar
14modelo.compile(
15    optimizer='adam',
16    loss='sparse_categorical_crossentropy',
17    metrics=['accuracy']
18)
19 
20# Entrenar
21modelo.fit(X_train, y_train, epochs=10, batch_size=32)
22 
23# Evaluar
24loss, accuracy = modelo.evaluate(X_test, y_test)
25print(f"Precisión: {accuracy:.2%}")

1pip install torch torchvision

1import torch
2import torch.nn as nn
3 
4# Definir red neuronal
5class MiRed(nn.Module):
6    def __init__(self):
7        super().__init__()
8        self.fc1 = nn.Linear(28*28, 128)
9        self.fc2 = nn.Linear(128, 64)
10        self.fc3 = nn.Linear(64, 10)
11 
12    def forward(self, x):
13        x = torch.relu(self.fc1(x))
14        x = torch.relu(self.fc2(x))
15        x = self.fc3(x)
16        return x
17 
18# Crear modelo
19modelo = MiRed()
20 
21# Pérdida y optimizador
22criterio = nn.CrossEntropyLoss()
23optimizador = torch.optim.Adam(modelo.parameters())
24 
25# Entrenar
26for epoch in range(10):
27    # Tu loop de entrenamiento aquí
28    pass

1pip install matplotlib seaborn

1import matplotlib.pyplot as plt
2import seaborn as sns
3 
4# Configurar estilo
5sns.set_style("darkgrid")
6 
7# Gráfico de línea
8plt.figure(figsize=(10, 6))
9plt.plot(historial['loss'], label='Pérdida entrenamiento')
10plt.plot(historial['val_loss'], label='Pérdida validación')
11plt.xlabel('Epoch')
12plt.ylabel('Pérdida')
13plt.legend()
14plt.title('Convergencia del Modelo')
15plt.show()
16 
17# Heatmap de correlación
18correlacion = df.corr()
19sns.heatmap(correlacion, annot=True, cmap='coolwarm')
20plt.show()

1# requirements.txt
2numpy==1.24.3
3pandas==2.0.3
4scikit-learn==1.3.0
5tensorflow==2.13.0
6torch==2.0.0
7matplotlib==3.7.2
8seaborn==0.12.2
9jupyter==1.0.0
10requests==2.31.0

1pip install -r requirements.txt

1import pandas as pd
2import numpy as np
3from sklearn.model_selection import train_test_split
4from sklearn.preprocessing import StandardScaler
5from sklearn.ensemble import RandomForestRegressor
6from sklearn.metrics import mean_squared_error, r2_score
7import matplotlib.pyplot as plt
8 
9# Cargar datos
10df = pd.read_csv('casas.csv')
11print(df.head())
12print(df.info())
13 
14# Exploración básica
15print(f"Dimensiones: {df.shape}")
16print(f"Valores nulos:\n{df.isnull().sum()}")
17print(f"Estadísticas:\n{df.describe()}")

1# Remover valores nulos
2df = df.dropna()
3 
4# Remover duplicados
5df = df.drop_duplicates()
6 
7# Outliers simples
8df = df[(df['precio'] < df['precio'].quantile(0.99))]
9 
10# Codificar variables categóricas
11df = pd.get_dummies(df, columns=['ciudad', 'tipo'])
12 
13print(f"Datos limpios: {df.shape}")

1# Separar features (X) y target (y)
2X = df.drop('precio', axis=1)
3y = df['precio']
4 
5# Dividir en entrenamiento y prueba
6X_train, X_test, y_train, y_test = train_test_split(
7    X, y, test_size=0.2, random_state=42
8)
9 
10# Normalizar features
11scaler = StandardScaler()
12X_train = scaler.fit_transform(X_train)
13X_test = scaler.transform(X_test)
14 
15print(f"Entrenamiento: {X_train.shape}")
16print(f"Prueba: {X_test.shape}")

1# Crear modelo
2modelo = RandomForestRegressor(
3    n_estimators=100,
4    max_depth=15,
5    min_samples_split=5,
6    random_state=42,
7    n_jobs=-1
8)
9 
10# Entrenar
11print("Entrenando modelo...")
12modelo.fit(X_train, y_train)
13print("¡Modelo entrenado!")
14 
15# Predicciones
16y_pred_train = modelo.predict(X_train)
17y_pred_test = modelo.predict(X_test)

1# Métricas de entrenamiento
2rmse_train = np.sqrt(mean_squared_error(y_train, y_pred_train))
3r2_train = r2_score(y_train, y_pred_train)
4 
5print(f"RMSE Entrenamiento: €{rmse_train:,.0f}")
6print(f"R² Entrenamiento: {r2_train:.4f}")
7 
8# Métricas de prueba
9rmse_test = np.sqrt(mean_squared_error(y_test, y_pred_test))
10r2_test = r2_score(y_test, y_pred_test)
11 
12print(f"RMSE Prueba: €{rmse_test:,.0f}")
13print(f"R² Prueba: {r2_test:.4f}")
14 
15# Feature importance
16importancia = pd.DataFrame({
17    'feature': X.columns,
18    'importancia': modelo.feature_importances_
19}).sort_values('importancia', ascending=False)
20 
21print("\nFeatures más importantes:")
22print(importancia.head(10))

1# Gráfico de predicciones vs. reales
2plt.figure(figsize=(12, 6))
3plt.scatter(y_test, y_pred_test, alpha=0.5)
4plt.plot([y_test.min(), y_test.max()],
5         [y_test.min(), y_test.max()], 'r--', lw=2)
6plt.xlabel('Precio Real')
7plt.ylabel('Precio Predicho')
8plt.title('Predicciones vs. Valores Reales')
9plt.show()
10 
11# Feature importance
12plt.figure(figsize=(10, 6))
13importancia.head(10).plot(x='feature', y='importancia', kind='barh')
14plt.xlabel('Importancia')
15plt.title('Top 10 Features Importantes')
16plt.tight_layout()
17plt.show()

1import pickle
2 
3# Guardar modelo
4with open('modelos/modelo_precios.pkl', 'wb') as f:
5    pickle.dump(modelo, f)
6 
7# Guardar scaler
8with open('modelos/scaler.pkl', 'wb') as f:
9    pickle.dump(scaler, f)
10 
11print("Modelo guardado")

1pip install openai anthropic requests

1from openai import OpenAI
2 
3client = OpenAI(api_key="tu_clave_aqui")
4 
5respuesta = client.chat.completions.create(
6    model="gpt-4",
7    messages=[
8        {"role": "system", "content": "Eres un experto en IA."},
9        {"role": "user", "content": "¿Qué es machine learning?"}
10    ],
11    temperature=0.7,
12    max_tokens=500
13)
14 
15print(respuesta.choices[0].message.content)

1from anthropic import Anthropic
2 
3client = Anthropic()
4 
5mensaje = client.messages.create(
6    model="claude-3-opus-20240229",
7    max_tokens=1024,
8    messages=[
9        {"role": "user",
10         "content": "Explica deep learning en 100 palabras"}
11    ]
12)
13 
14print(mensaje.content[0].text)