Como Crear una Inteligencia Artificial desde Cero: Tutorial Python Paso a Paso [2026]

1# Crear un entorno virtual (recomendado)
2python -m venv ia-tutorial
3source ia-tutorial/bin/activate   # En Linux/macOS
4# ia-tutorial\Scripts\activate    # En Windows
5 
6# Instalar las dependencias para los 3 proyectos
7pip install torch torchvision matplotlib numpy
8pip install openai python-dotenv
9pip install langchain langchain-openai langchain-community
10 
11# Verificar que todo esta instalado
12python -c "import torch; print(f'PyTorch {torch.__version__} instalado correctamente')"
13python -c "import openai; print(f'OpenAI SDK {openai.__version__} instalado correctamente')"
14python -c "import langchain; print(f'LangChain {langchain.__version__} instalado correctamente')"

1import torch
2import torch.nn as nn
3import torch.optim as optim
4from torchvision import datasets, transforms
5from torch.utils.data import DataLoader
6import matplotlib.pyplot as plt
7import time
8 
9# ============================================================
10# PASO 1: Preparar los datos
11# ============================================================
12 
13# Transformaciones: convertir imagenes a tensores y normalizar
14transformacion = transforms.Compose([
15    transforms.ToTensor(),
16    transforms.Normalize((0.1307,), (0.3081,))  # Media y std de MNIST
17])
18 
19# Descargar y cargar el dataset MNIST
20datos_entrenamiento = datasets.MNIST(
21    root='./datos',
22    train=True,
23    download=True,
24    transform=transformacion
25)
26 
27datos_prueba = datasets.MNIST(
28    root='./datos',
29    train=False,
30    download=True,
31    transform=transformacion
32)
33 
34# DataLoaders: cargan los datos en lotes de 64 imagenes
35cargador_entrenamiento = DataLoader(datos_entrenamiento, batch_size=64, shuffle=True)
36cargador_prueba = DataLoader(datos_prueba, batch_size=1000, shuffle=False)
37 
38print(f"Imagenes de entrenamiento: {len(datos_entrenamiento)}")
39print(f"Imagenes de prueba: {len(datos_prueba)}")
40print(f"Tamano de cada imagen: {datos_entrenamiento[0][0].shape}")
41 
42# ============================================================
43# PASO 2: Definir la red neuronal
44# ============================================================
45 
46class RedNeuronal(nn.Module):
47    def __init__(self):
48        super(RedNeuronal, self).__init__()
49 
50        # Capa 1: 784 entradas (28x28 pixeles) -> 256 neuronas
51        self.capa1 = nn.Linear(784, 256)
52 
53        # Capa 2: 256 neuronas -> 128 neuronas
54        self.capa2 = nn.Linear(256, 128)
55 
56        # Capa 3: 128 neuronas -> 64 neuronas
57        self.capa3 = nn.Linear(128, 64)
58 
59        # Capa de salida: 64 neuronas -> 10 clases (digitos 0-9)
60        self.salida = nn.Linear(64, 10)
61 
62        # Funcion de activacion ReLU (convierte negativos en 0)
63        self.relu = nn.ReLU()
64 
65        # Dropout para evitar sobreajuste (apaga 20% de neuronas aleatoriamente)
66        self.dropout = nn.Dropout(0.2)
67 
68    def forward(self, x):
69        # Aplanar la imagen de 28x28 a un vector de 784
70        x = x.view(-1, 784)
71 
72        # Pasar por cada capa con activacion ReLU y dropout
73        x = self.dropout(self.relu(self.capa1(x)))
74        x = self.dropout(self.relu(self.capa2(x)))
75        x = self.relu(self.capa3(x))
76        x = self.salida(x)
77 
78        return x
79 
80# Crear la red
81red = RedNeuronal()
82 
83# Contar parametros totales
84total_parametros = sum(p.numel() for p in red.parameters())
85print(f"\nArquitectura de la red:")
86print(red)
87print(f"\nParametros totales: {total_parametros:,}")
88 
89# ============================================================
90# PASO 3: Configurar el entrenamiento
91# ============================================================
92 
93# Funcion de perdida: Cross Entropy (estandar para clasificacion)
94criterio = nn.CrossEntropyLoss()
95 
96# Optimizador: Adam (ajusta los pesos automaticamente)
97optimizador = optim.Adam(red.parameters(), lr=0.001)
98 
99# ============================================================
100# PASO 4: Entrenar la red neuronal
101# ============================================================
102 
103EPOCAS = 10
104historial_perdida = []
105historial_precision = []
106 
107print("\nIniciando entrenamiento...")
108inicio = time.time()
109 
110for epoca in range(EPOCAS):
111    red.train()  # Modo entrenamiento (activa dropout)
112    perdida_total = 0
113    lotes_procesados = 0
114 
115    for imagenes, etiquetas in cargador_entrenamiento:
116        # Forward: calcular prediccion
117        predicciones = red(imagenes)
118 
119        # Calcular perdida (error)
120        perdida = criterio(predicciones, etiquetas)
121 
122        # Backward: calcular gradientes
123        optimizador.zero_grad()
124        perdida.backward()
125 
126        # Actualizar pesos
127        optimizador.step()
128 
129        perdida_total += perdida.item()
130        lotes_procesados += 1
131 
132    # Evaluar precision en datos de prueba
133    red.eval()  # Modo evaluacion (desactiva dropout)
134    correctas = 0
135    total = 0
136 
137    with torch.no_grad():  # No calcular gradientes (ahorra memoria)
138        for imagenes, etiquetas in cargador_prueba:
139            predicciones = red(imagenes)
140            _, predichas = torch.max(predicciones, 1)
141            total += etiquetas.size(0)
142            correctas += (predichas == etiquetas).sum().item()
143 
144    precision = 100 * correctas / total
145    perdida_media = perdida_total / lotes_procesados
146 
147    historial_perdida.append(perdida_media)
148    historial_precision.append(precision)
149 
150    print(f"Epoca {epoca+1}/{EPOCAS} | "
151          f"Perdida: {perdida_media:.4f} | "
152          f"Precision: {precision:.2f}%")
153 
154tiempo_total = time.time() - inicio
155print(f"\nEntrenamiento completado en {tiempo_total:.1f} segundos")
156print(f"Precision final: {precision:.2f}%")
157 
158# ============================================================
159# PASO 5: Visualizar resultados
160# ============================================================
161 
162fig, axes = plt.subplots(1, 2, figsize=(12, 4))
163 
164# Grafico de perdida
165axes[0].plot(historial_perdida, 'b-o')
166axes[0].set_title('Perdida durante entrenamiento')
167axes[0].set_xlabel('Epoca')
168axes[0].set_ylabel('Perdida')
169axes[0].grid(True)
170 
171# Grafico de precision
172axes[1].plot(historial_precision, 'g-o')
173axes[1].set_title('Precision en datos de prueba')
174axes[1].set_xlabel('Epoca')
175axes[1].set_ylabel('Precision (%)')
176axes[1].grid(True)
177 
178plt.tight_layout()
179plt.savefig('resultados_entrenamiento.png', dpi=150)
180plt.show()
181print("Graficos guardados en resultados_entrenamiento.png")
182 
183# ============================================================
184# PASO 6: Probar con imagenes individuales
185# ============================================================
186 
187# Tomar 10 imagenes de prueba y mostrar las predicciones
188fig, axes = plt.subplots(2, 5, figsize=(12, 5))
189red.eval()
190 
191for i, ax in enumerate(axes.flat):
192    imagen, etiqueta_real = datos_prueba[i]
193    with torch.no_grad():
194        prediccion = red(imagen.unsqueeze(0))
195        digito_predicho = prediccion.argmax().item()
196 
197    ax.imshow(imagen.squeeze(), cmap='gray')
198    color = 'green' if digito_predicho == etiqueta_real else 'red'
199    ax.set_title(f'Pred: {digito_predicho} (Real: {etiqueta_real})', color=color)
200    ax.axis('off')
201 
202plt.tight_layout()
203plt.savefig('predicciones.png', dpi=150)
204plt.show()
205print("Predicciones guardadas en predicciones.png")

1python red_neuronal.py

1Imagenes de entrenamiento: 60000
2Imagenes de prueba: 10000
3Tamano de cada imagen: torch.Size([1, 28, 28])
4 
5Parametros totales: 237,066
6 
7Iniciando entrenamiento...
8Epoca 1/10  | Perdida: 0.3521 | Precision: 95.48%
9Epoca 2/10  | Perdida: 0.1498 | Precision: 96.72%
10Epoca 3/10  | Perdida: 0.1089 | Precision: 97.15%
11...
12Epoca 10/10 | Perdida: 0.0412 | Precision: 97.83%
13 
14Entrenamiento completado en 47.3 segundos
15Precision final: 97.83%

1# .env
2OPENAI_API_KEY=tu-clave-api-aqui

1import os
2from openai import OpenAI
3from dotenv import load_dotenv
4from datetime import datetime
5 
6# Cargar variables de entorno
7load_dotenv()
8 
9# ============================================================
10# PASO 1: Configurar el cliente de OpenAI
11# ============================================================
12 
13cliente = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
14 
15# ============================================================
16# PASO 2: Definir el sistema de conversacion con memoria
17# ============================================================
18 
19class ChatbotIA:
20    def __init__(self, personalidad="asistente"):
21        """Inicializar el chatbot con una personalidad y memoria vacia."""
22 
23        # Diferentes personalidades predefinidas
24        personalidades = {
25            "asistente": (
26                "Eres un asistente de IA amable y util. Respondes en espanol "
27                "de forma clara y concisa. Si no sabes algo, lo dices honestamente."
28            ),
29            "profesor": (
30                "Eres un profesor de informatica paciente y pedagogico. "
31                "Explicas conceptos tecnicos con analogias simples y ejemplos "
32                "del mundo real. Siempre en espanol."
33            ),
34            "programador": (
35                "Eres un programador senior experto en Python y machine learning. "
36                "Cuando te preguntan algo, das la respuesta tecnica precisa con "
37                "codigo de ejemplo. Siempre en espanol."
38            ),
39        }
40 
41        self.mensaje_sistema = personalidades.get(personalidad, personalidades["asistente"])
42        self.modelo = "gpt-4o-mini"  # Modelo rapido y economico
43        self.historial = []
44        self.personalidad = personalidad
45        self.tokens_usados = 0
46 
47    def enviar_mensaje(self, mensaje_usuario):
48        """Enviar un mensaje y obtener respuesta manteniendo el contexto."""
49 
50        # Agregar mensaje del usuario al historial
51        self.historial.append({
52            "role": "user",
53            "content": mensaje_usuario
54        })
55 
56        # Construir la lista completa de mensajes (sistema + historial)
57        mensajes = [
58            {"role": "system", "content": self.mensaje_sistema}
59        ] + self.historial
60 
61        # Llamar a la API de OpenAI
62        respuesta = cliente.chat.completions.create(
63            model=self.modelo,
64            messages=mensajes,
65            temperature=0.7,    # Creatividad (0=predecible, 1=creativo)
66            max_tokens=1000,    # Longitud maxima de respuesta
67        )
68 
69        # Extraer la respuesta del asistente
70        mensaje_asistente = respuesta.choices[0].message.content
71 
72        # Guardar la respuesta en el historial (esto es la "memoria")
73        self.historial.append({
74            "role": "assistant",
75            "content": mensaje_asistente
76        })
77 
78        # Contabilizar tokens
79        self.tokens_usados += respuesta.usage.total_tokens
80 
81        return mensaje_asistente
82 
83    def limpiar_memoria(self):
84        """Borrar el historial de conversacion."""
85        self.historial = []
86        print("Memoria limpiada. Nueva conversacion.")
87 
88    def ver_estadisticas(self):
89        """Mostrar estadisticas de la conversacion."""
90        mensajes_usuario = len([m for m in self.historial if m["role"] == "user"])
91        mensajes_bot = len([m for m in self.historial if m["role"] == "assistant"])
92        coste_estimado = (self.tokens_usados / 1_000_000) * 0.15  # Precio gpt-4o-mini
93 
94        print(f"\n--- Estadisticas ---")
95        print(f"Personalidad: {self.personalidad}")
96        print(f"Mensajes del usuario: {mensajes_usuario}")
97        print(f"Respuestas del bot: {mensajes_bot}")
98        print(f"Tokens totales usados: {self.tokens_usados:,}")
99        print(f"Coste estimado: {coste_estimado:.4f} EUR")
100        print(f"--------------------\n")
101 
102# ============================================================
103# PASO 3: Interfaz de conversacion interactiva
104# ============================================================
105 
106def main():
107    print("=" * 50)
108    print("  CHATBOT IA - Tutorial Javadex")
109    print("=" * 50)
110    print("\nElige una personalidad:")
111    print("  1. Asistente general")
112    print("  2. Profesor de informatica")
113    print("  3. Programador senior")
114 
115    opcion = input("\nOpcion (1/2/3): ").strip()
116    personalidades = {"1": "asistente", "2": "profesor", "3": "programador"}
117    personalidad = personalidades.get(opcion, "asistente")
118 
119    bot = ChatbotIA(personalidad=personalidad)
120    print(f"\nChatbot '{personalidad}' activado. Escribe tu mensaje.")
121    print("Comandos: 'salir', 'limpiar', 'stats'\n")
122 
123    while True:
124        entrada = input("Tu: ").strip()
125 
126        if not entrada:
127            continue
128        if entrada.lower() == "salir":
129            bot.ver_estadisticas()
130            print("Hasta luego.")
131            break
132        if entrada.lower() == "limpiar":
133            bot.limpiar_memoria()
134            continue
135        if entrada.lower() == "stats":
136            bot.ver_estadisticas()
137            continue
138 
139        respuesta = bot.enviar_mensaje(entrada)
140        print(f"\nBot: {respuesta}\n")
141 
142if __name__ == "__main__":
143    main()

1# Instalar Ollama (macOS/Linux)
2curl -fsSL https://ollama.com/install.sh | sh
3 
4# Descargar un modelo ligero (3.8 GB)
5ollama pull llama3.2
6 
7# Verificar que funciona
8ollama run llama3.2 "Di hola en espanol"

1import requests
2import json
3 
4# ============================================================
5# Chatbot con Ollama (ejecucion 100% local y gratuita)
6# ============================================================
7 
8class ChatbotLocal:
9    def __init__(self, modelo="llama3.2"):
10        """Inicializar chatbot con Ollama local."""
11        self.modelo = modelo
12        self.url = "http://localhost:11434/api/chat"
13        self.historial = []
14        self.mensaje_sistema = (
15            "Eres un asistente de IA util y amable. "
16            "Respondes siempre en espanol de forma clara y concisa."
17        )
18 
19    def enviar_mensaje(self, mensaje_usuario):
20        """Enviar mensaje a Ollama y obtener respuesta con contexto."""
21 
22        self.historial.append({
23            "role": "user",
24            "content": mensaje_usuario
25        })
26 
27        mensajes = [
28            {"role": "system", "content": self.mensaje_sistema}
29        ] + self.historial
30 
31        payload = {
32            "model": self.modelo,
33            "messages": mensajes,
34            "stream": False,
35            "options": {
36                "temperature": 0.7,
37                "num_predict": 1000,
38            }
39        }
40 
41        try:
42            respuesta = requests.post(self.url, json=payload)
43            respuesta.raise_for_status()
44            datos = respuesta.json()
45            mensaje_asistente = datos["message"]["content"]
46 
47            self.historial.append({
48                "role": "assistant",
49                "content": mensaje_asistente
50            })
51 
52            return mensaje_asistente
53 
54        except requests.exceptions.ConnectionError:
55            return ("Error: No se pudo conectar con Ollama. "
56                    "Asegurate de que Ollama esta ejecutandose "
57                    "(ejecuta 'ollama serve' en otra terminal).")
58 
59    def limpiar_memoria(self):
60        """Borrar historial de conversacion."""
61        self.historial = []
62        print("Memoria limpiada.")
63 
64def main():
65    print("=" * 50)
66    print("  CHATBOT LOCAL - Ollama + Llama 3.2")
67    print("=" * 50)
68    print("\nAsegurate de que Ollama esta activo: 'ollama serve'")
69    print("Comandos: 'salir', 'limpiar'\n")
70 
71    bot = ChatbotLocal()
72 
73    while True:
74        entrada = input("Tu: ").strip()
75 
76        if not entrada:
77            continue
78        if entrada.lower() == "salir":
79            print("Hasta luego.")
80            break
81        if entrada.lower() == "limpiar":
82            bot.limpiar_memoria()
83            continue
84 
85        respuesta = bot.enviar_mensaje(entrada)
86        print(f"\nBot: {respuesta}\n")
87 
88if __name__ == "__main__":
89    main()

1# Opcion A: Con OpenAI API
2python chatbot_openai.py
3 
4# Opcion B: Con Ollama (gratis, en otra terminal ejecuta: ollama serve)
5python chatbot_ollama.py

1Tu: Hola, me llamo Carlos y estoy aprendiendo Python
2 
3Bot: Hola Carlos, encantado de conocerte. Python es una
4excelente eleccion para empezar a programar. Es el lenguaje
5mas usado en inteligencia artificial y ciencia de datos.
6Que te gustaria aprender hoy?
7 
8Tu: Recuerdas mi nombre?
9 
10Bot: Claro, te llamas Carlos. Me lo has dicho al principio
11de nuestra conversacion. Que mas puedo ayudarte?
12 
13Tu: Explica que es una lista en Python con un ejemplo simple
14 
15Bot: Una lista en Python es como una caja donde puedes guardar
16varios elementos en orden. Se crea con corchetes:
17 
18frutas = ["manzana", "platano", "naranja"]
19print(frutas[0])   # manzana
20frutas.append("uva")  # Anadir un elemento
21print(len(frutas))  # 4

1import os
2from dotenv import load_dotenv
3from langchain_openai import ChatOpenAI
4from langchain.agents import AgentExecutor, create_react_agent
5from langchain.tools import Tool
6from langchain import hub
7import requests
8import json
9from datetime import datetime
10 
11load_dotenv()
12 
13# ============================================================
14# PASO 1: Definir las herramientas del agente
15# ============================================================
16 
17def calculadora(expresion: str) -> str:
18    """Evalua una expresion matematica y devuelve el resultado."""
19    try:
20        # Sanitizar la entrada (solo permitir caracteres matematicos)
21        caracteres_permitidos = set("0123456789+-*/.() ")
22        if not all(c in caracteres_permitidos for c in expresion):
23            return "Error: La expresion contiene caracteres no permitidos."
24 
25        resultado = eval(expresion)
26        return f"El resultado de {expresion} es: {resultado}"
27    except Exception as e:
28        return f"Error al calcular: {str(e)}"
29 
30def obtener_fecha_hora(consulta: str = "") -> str:
31    """Devuelve la fecha y hora actual."""
32    ahora = datetime.now()
33    return (
34        f"Fecha actual: {ahora.strftime('%d de %B de %Y')}. "
35        f"Hora: {ahora.strftime('%H:%M:%S')}. "
36        f"Dia de la semana: {ahora.strftime('%A')}."
37    )
38 
39def buscar_wikipedia(consulta: str) -> str:
40    """Busca informacion en Wikipedia en espanol."""
41    url = "https://es.wikipedia.org/api/rest_v1/page/summary/"
42    consulta_formateada = consulta.strip().replace(" ", "_")
43 
44    try:
45        respuesta = requests.get(
46            f"{url}{consulta_formateada}",
47            headers={"User-Agent": "AgenteTutorial/1.0"},
48            timeout=10
49        )
50 
51        if respuesta.status_code == 200:
52            datos = respuesta.json()
53            titulo = datos.get("title", "Sin titulo")
54            extracto = datos.get("extract", "Sin informacion disponible.")
55            url_completa = datos.get("content_urls", {}).get("desktop", {}).get("page", "")
56            return (
57                f"Titulo: {titulo}\n"
58                f"Resumen: {extracto}\n"
59                f"Fuente: {url_completa}"
60            )
61        elif respuesta.status_code == 404:
62            return f"No se encontro un articulo de Wikipedia para '{consulta}'."
63        else:
64            return f"Error al consultar Wikipedia: HTTP {respuesta.status_code}"
65 
66    except requests.exceptions.Timeout:
67        return "Error: La consulta a Wikipedia tardo demasiado."
68    except Exception as e:
69        return f"Error inesperado: {str(e)}"
70 
71def analizar_texto(texto: str) -> str:
72    """Analiza un texto y devuelve estadisticas basicas."""
73    palabras = texto.split()
74    oraciones = texto.count('.') + texto.count('!') + texto.count('?')
75    caracteres = len(texto)
76 
77    return (
78        f"Analisis del texto:\n"
79        f"- Palabras: {len(palabras)}\n"
80        f"- Oraciones: {max(oraciones, 1)}\n"
81        f"- Caracteres: {caracteres}\n"
82        f"- Palabras por oracion: {len(palabras) / max(oraciones, 1):.1f}\n"
83        f"- Palabra mas larga: {max(palabras, key=len) if palabras else 'N/A'}"
84    )
85 
86# ============================================================
87# PASO 2: Registrar las herramientas
88# ============================================================
89 
90herramientas = [
91    Tool(
92        name="Calculadora",
93        func=calculadora,
94        description=(
95            "Util para resolver operaciones matematicas. "
96            "La entrada debe ser una expresion matematica valida, "
97            "por ejemplo: '2 + 2' o '(100 * 0.21) + 500'"
98        )
99    ),
100    Tool(
101        name="FechaHora",
102        func=obtener_fecha_hora,
103        description=(
104            "Devuelve la fecha y hora actual. "
105            "Usar cuando el usuario pregunte por la fecha o la hora."
106        )
107    ),
108    Tool(
109        name="Wikipedia",
110        func=buscar_wikipedia,
111        description=(
112            "Busca informacion en Wikipedia en espanol. "
113            "La entrada debe ser el termino o concepto a buscar, "
114            "por ejemplo: 'Inteligencia artificial' o 'Python lenguaje'"
115        )
116    ),
117    Tool(
118        name="AnalizadorTexto",
119        func=analizar_texto,
120        description=(
121            "Analiza un texto y devuelve estadisticas como numero de "
122            "palabras, oraciones y caracteres. La entrada es el texto a analizar."
123        )
124    ),
125]
126 
127# ============================================================
128# PASO 3: Crear el agente con LangChain
129# ============================================================
130 
131def crear_agente():
132    """Configurar y devolver el agente IA."""
133 
134    # Modelo de lenguaje (puedes cambiar a Ollama para ejecucion local)
135    llm = ChatOpenAI(
136        model="gpt-4o-mini",
137        temperature=0.3,  # Baja creatividad para respuestas precisas
138    )
139 
140    # Prompt del agente ReAct (descargado de LangChain Hub)
141    prompt = hub.pull("hwchase17/react")
142 
143    # Crear el agente
144    agente = create_react_agent(llm, herramientas, prompt)
145 
146    # Ejecutor del agente (gestiona el ciclo ReAct)
147    ejecutor = AgentExecutor(
148        agent=agente,
149        tools=herramientas,
150        verbose=True,       # Mostrar el razonamiento paso a paso
151        max_iterations=8,   # Maximo de pasos para evitar bucles
152        handle_parsing_errors=True,
153    )
154 
155    return ejecutor
156 
157# ============================================================
158# PASO 4: Interfaz interactiva
159# ============================================================
160 
161def main():
162    print("=" * 55)
163    print("  AGENTE IA AUTONOMO - Tutorial Javadex")
164    print("=" * 55)
165    print("\nEste agente puede:")
166    print("  - Buscar informacion en Wikipedia")
167    print("  - Resolver calculos matematicos")
168    print("  - Decir la fecha y hora actual")
169    print("  - Analizar textos")
170    print("\nEscribe 'salir' para terminar.\n")
171 
172    agente = crear_agente()
173 
174    while True:
175        pregunta = input("Tu pregunta: ").strip()
176 
177        if not pregunta:
178            continue
179        if pregunta.lower() == "salir":
180            print("Hasta luego.")
181            break
182 
183        print("\n--- Razonamiento del agente ---\n")
184 
185        try:
186            resultado = agente.invoke({"input": pregunta})
187            print(f"\n--- Respuesta final ---")
188            print(f"\n{resultado['output']}\n")
189        except Exception as e:
190            print(f"\nError: {str(e)}\n")
191 
192if __name__ == "__main__":
193    main()

1python agente_ia.py

1Tu pregunta: Que es PyTorch y en que ano se creo?
2 
3--- Razonamiento del agente ---
4 
5> Entering new AgentExecutor chain...
6Thought: El usuario quiere saber que es PyTorch y cuando se creo.
7Voy a buscar esta informacion en Wikipedia.
8 
9Action: Wikipedia
10Action Input: PyTorch
11 
12Observation: Titulo: PyTorch
13Resumen: PyTorch es una biblioteca de aprendizaje automatico
14de codigo abierto basada en la biblioteca Torch, utilizada
15para aplicaciones como vision por computador y procesamiento
16del lenguaje natural. Fue desarrollada principalmente por
17el laboratorio de investigacion de IA de Meta (Facebook).
18Su primera version fue lanzada en septiembre de 2016...
19Fuente: https://es.wikipedia.org/wiki/PyTorch
20 
21Thought: Ya tengo la informacion necesaria para responder.
22 
23Final Answer: PyTorch es una biblioteca de aprendizaje automatico
24de codigo abierto desarrollada por Meta (Facebook). Se utiliza
25principalmente para vision por computador y procesamiento del
26lenguaje natural. Fue creada en septiembre de 2016. Es una de
27las bibliotecas mas populares para deep learning junto con
28TensorFlow.
29 
30--- Respuesta final ---
31 
32PyTorch es una biblioteca de aprendizaje automatico de codigo
33abierto desarrollada por Meta (Facebook). Se utiliza
34principalmente para vision por computador y procesamiento
35del lenguaje natural. Fue creada en septiembre de 2016.
36Es una de las bibliotecas mas populares para deep learning
37junto con TensorFlow.

1from langchain_community.llms import Ollama
2 
3# Reemplazar ChatOpenAI por Ollama
4llm = Ollama(
5    model="llama3.2",
6    temperature=0.3,
7)