Please enable JavaScript.
Coggle requires JavaScript to display documents.
4.2 Ejemplos con librerías de IA. - Coggle Diagram
4.2 Ejemplos con librerías de IA.
La programación con librerías de inteligencia artificial (IA) en Python es muy popular debido a la riqueza del ecosistema de librerías disponibles. A continuación, se presentan ejemplos de cómo utilizar algunas de las librerías de IA más comunes en Python: TensorFlow, PyTorch, Scikit-learn, y NLTK.
TensorFlow: Clasificación de Imágenes
TensorFlow es una librería de código abierto para computación numérica y aprendizaje automático. Aquí se muestra un ejemplo de cómo crear y entrenar un modelo simple de red neuronal para clasificar imágenes utilizando el conjunto de datos MNIST.
import tensorflow as tf
from tensorflow.keras import layers, models
Cargar el conjunto de datos MNIST
mnist = tf.keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
Normalizar las imágenes
train_images = train_images / 255.0
test_images = test_images / 255.0
Crear el modelo
model = models.Sequential([
layers.Flatten(input_shape=(28, 28)),
layers.Dense(128, activation='relu'),
layers.Dense(10, activation='softmax')
])
Compilar el modelo
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
Entrenar el modelo
model.fit(train_images, train_labels, epochs=5)
Evaluar el modelo
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'Precisión en el conjunto de prueba: {test_acc}')
PyTorch: Red Neuronal Simple
PyTorch es una librería de aprendizaje automático que proporciona tensores y automatización de la diferenciación. A continuación, se muestra cómo crear y entrenar una red neuronal simple para clasificar dígitos MNIST.
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
Definir transformaciones
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
Cargar el conjunto de datos MNIST
trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
Definir el modelo
class SimpleNN(nn.Module):
def
init
(self):
super(SimpleNN, self).
init
()
self.fc1 = nn.Linear(28 * 28, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = x.view(-1, 28 * 28)
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x
model = SimpleNN()
Definir el optimizador y la función de pérdida
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
Entrenar el modelo
for epoch in range(5):
running_loss = 0.0
for images, labels in trainloader:
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
print(f'Epoch {epoch+1}, Loss: {running_loss/len(trainloader)}')
Evaluar el modelo (aquí se puede cargar el conjunto de pruebas de manera similar a como se cargó el de entrenamiento)
Scikit-learn: Clasificación de Iris
Scikit-learn es una librería de aprendizaje automático para Python que ofrece herramientas simples y eficientes para análisis de datos. A continuación, se muestra cómo usarla para clasificar el conjunto de datos Iris utilizando un clasificador de K-Vecinos Más Cercanos (KNN).
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
Cargar el conjunto de datos Iris
iris = load_iris()
X = iris.data
y = iris.target
Dividir el conjunto de datos en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
Crear el modelo KNN
knn = KNeighborsClassifier(n_neighbors=3)
Entrenar el modelo
knn.fit(X_train, y_train)
Predecir sobre el conjunto de prueba
y_pred = knn.predict(X_test)
Evaluar el modelo
accuracy = accuracy_score(y_test, y_pred)
print(f'Precisión: {accuracy}')
NLTK: Procesamiento de Lenguaje Natural
NLTK es una librería de Python para trabajar con datos de lenguaje humano (texto). A continuación, se muestra cómo usar NLTK para tokenizar un texto y analizar su frecuencia de palabras.