Machine learning
Flujo de trabajo
1. Recolección de datos
2. Limpieza y preprocesamiento
3. División de datos (normalmente 80-70% entrenamiento, 20-30% prueba)
4. Entrenamiento del modelo (ajustar parámetros con el conjunto de entrenamiento)
5. Evaluación
6. Optimización
7. Interpretabilidad
8. Implementación
Lenguaj Librerías clave
e
R caret, mlr, tidymodels, randomForest, e1071, nnet, xgboost, keras
Python scikit-learn, tensorflow, pandas, numpy, matplotlib, seaborn, xgboost, pytorch
En programación…
Lo más básico:
1. Cargar y explorar los datos
2. Limpiar, transformar y visualizar
3. Separar conjuntos de entrenamiento y prueba
4. Crear, entrenar y evaluar modelos
Python
import pandas as pd
# Cargar datos
df = pd.read_csv("[Link]")
# Ver primeras filas
print([Link]())
# Información general
print([Link]())
# Estadísticas descriptivas
print([Link]())
# Verificar valores faltantes
print([Link]().sum())
R
# Cargar librerías
library(readr)
library(dplyr)
# Leer datos
df <- read_csv("[Link]")
# Primeras filas
head(df)
# Resumen
summary(df)
# Estructura
str(df)
# Valores faltantes
colSums([Link](df))
Ejemplo: base de pacientes con edad, presión arterial, glucosa y diagnóstico de hipertensión
Python
# Seleccionar columnas
df[['edad', 'presion']]
# Filtrar pacientes hipertensos
hipertensos = df[df['diagnostico'] == 'Hipertension']
# Crear columna nueva
df['IMC'] = df['peso'] / (df['altura'] ** 2)
# Agrupar por género y obtener media
[Link]('genero')['edad'].mean()
df %>%
select(edad, presion) %>%
filter(diagnostico == "Hipertension") %>%
mutate(IMC = peso / (altura^2)) %>%
group_by(genero) %>%
🧐
summarise(edad_media = mean(edad, [Link] = TRUE))
Visualización….
import [Link] as plt
import seaborn as sns
# Histograma
[Link](df['edad'])
[Link]()
# Boxplot por diagnóstico
[Link](x='diagnostico', y='presion', data=df)
[Link]()
En R
library(ggplot2)
# Histograma
ggplot(df, aes(x = edad)) + geom_histogram(binwidth = 5, fill = "skyblue")
# Boxplot
ggplot(df, aes(x = diagnostico, y = presion, fill = diagnostico)) +
geom_boxplot()
1. División de datos (train/test split)
Python
from sklearn.model_selection import train_test_split
X = df[['edad', 'presion', 'glucosa']]
y = df['diagnostico']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
—> test_size:
● Indica qué proporción del total de datos se usará para el conjunto de prueba.
● 0.2 significa 20% de los datos se reserva para prueba, y el 80% para entrenamiento.
—> random_state = 42
● Controla la aleatoriedad de la división (es como el [Link] para reproducibilidad de datos
R
[Link](42)
library(caret)
trainIndex <- createDataPartition(df$diagnostico, p = 0.8, list = FALSE)
train <- df[trainIndex, ]
test <- df[-trainIndex, ]
1. Entrenamiento de modelos básicos
Ejemplo 1: Regresión logística
from sklearn.linear_model import LogisticRegression
from [Link] import accuracy_score, confusion_matrix
model = LogisticRegression()
[Link](X_train, y_train)
pred = [Link](X_test)
print("Accuracy:", accuracy_score(y_test, pred))
print(confusion_matrix(y_test, pred))
—> Recordar que la regresión logística estima la probabilidad de pertenecer a una clase usando la
función logística.
—> Accuray_score : mide la proporción de aciertos (predicciones correctas)
—> confusion_matrix: muestra cuántos casos fueron bien o mal clasificados
model = LogisticRegression()
● Crea un objeto modelo de regresión logística vacío (aún no entrenado)
● max_iter número máximo de iteraciones para ajustar el modelo
● Solver método numérico usado para encontrar los coeficientes
[Link](X_train, y_train)
● Entrena el modelo con los datos de entrenamiento
● X_train: son las variables predictoras
● y_train es la variable objetivo
pred = [Link](X_test), una vez entrenado, el modelo se usa para predecir con nuevos datos (que
nunca ha visto).
print(“Accuracy:”, accuracy_score(y_test, pred))
● Calcula el porcentaje de aciertos comparando las predicciones del modelo (pred) con los
valores reales (y_test)
Número de predicciones correctas/total de observaciones
print(confussion_matrix(y_test,pred))
Muestra una tabla 2x2, que detalla los errores y aciertos del modelo. Para este caso verdaderos
negativos, falsos positivos, falso negativo y verdaderos positivos
Línea Qué hace Concepto
from sklearn.linear_model import Carga el modelo logístico Modelo estadístico
LogisticRegression
from [Link] import accuracy_score, Carga funciones de Medición de
confusion_matrix evaluación rendimiento
model = LogisticRegression() Crea el modelo Inicialización
[Link](X_train, y_train) Entrena el modelo Ajuste de
parámetros
pred = [Link](X_test) Predice nuevas Inferencia
observaciones
accuracy_score(y_test, pred) Calcula precisión global Evaluación
confusion_matrix(y_test, pred) Muestra matriz de aciertos y Diagnóstico del
errores modelo
1. Evaluación de modelos
from [Link] import confusion_matrix, classification_report, roc_auc_score
print(confusion_matrix(y_test, pred))
print(classification_report(y_test, pred))
print("AUC:", roc_auc_score(y_test, model.predict_proba(X_test)[:,1]))
—>
Qué es el Machine Learning?
Es un conjunto de métodos que permiten que un algoritmo aprenda patrones desde los
datos, sin ser programado explícitamente para cada tarea.
Tipos de problemas
1. Clasificación (categorías)
2. Regresión (valores continuos)
3. Clustering (agrupar sin etiquetas)
4. Reducción de dimensionalidad (simplificar datos)
5. Series de tiempo (predicción temporal)
Conceptos clave
● Datos de entrenamiento
● Datos de prueba
● Overfitting
● Underfitting
● Exactitud, precisión, recall, F1
● Matriz de confusión
● Validación cruzada
🟩 Módulo 2 · Preparación de Datos (1
hora)
Pasos esenciales
● Importar datos
● Manejo de valores faltantes
● Normalización / estandarización
● One-hot encoding
● División train/test
En R
library(dplyr)
library(caret)
data <- [Link]("[Link]")
# dividir datos
[Link](123)
trainIndex <- createDataPartition(data$clase, p = 0.7, list = FALSE)
train <- data[trainIndex, ]
test <- data[-trainIndex, ]
En Python
import pandas as pd
from sklearn.model_selection import train_test_split
data = pd.read_csv("[Link]")
train, test = train_test_split(data, test_size=0.3, random_state=123)
🟨 Módulo 3 · Algoritmos Básicos
Supervisados (2 horas)
3.1 Regresión Lineal (para predicción continua)
Idea:
Encuentra la línea que mejor ajusta los datos.
En R
modelo <- lm(y ~ x1 + x2, data = train)
summary(modelo)
En Python
from sklearn.linear_model import LinearRegression
model = LinearRegression()
[Link](train[["x1","x2"]], train["y"])
3.2 Regresión Logística (para clasificación binaria)
En R
modelo <- glm(clase ~ x1 + x2, family = binomial, data = train)
summary(modelo)
En Python
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
[Link](train[["x1","x2"]], train["clase"])
3.3 Árboles de Decisión
En R
library(rpart)
modelo <- rpart(clase ~ ., data = train)
En Python
from [Link] import DecisionTreeClassifier
model = DecisionTreeClassifier()
[Link]([Link]("clase",axis=1), train["clase"])
3.4 Random Forest (muy usado)
En R
library(randomForest)
modelo <- randomForest(clase ~ ., data = train, ntree = 500)
En Python
from [Link] import RandomForestClassifier
model = RandomForestClassifier(n_estimators=500)
[Link]([Link]("clase",axis=1), train["clase"])
🟧 Módulo 4 · Algoritmos No
Supervisados (1 hora)
4.1 K-Means
Agrupa según similitud.
En R
[Link](123)
kmeans(train[,1:4], centers = 3)
En Python
from [Link] import KMeans
kmeans = KMeans(n_clusters=3)
[Link]([Link][:,:4])
4.2 PCA (reducción de dimensionalidad)
En R
pca <- prcomp(train[,1:5], scale = TRUE)
summary(pca)
En Python
from [Link] import PCA
pca = PCA(n_components=2)
[Link]([Link][:,:5])
🟪 Módulo 5 · Evaluación de Modelos (1
hora)
Clasificación
● Accuracy
● Precision
● Recall
● F1 Score
● Matriz de confusión
En R
confusionMatrix(pred, test$clase)
En Python
from [Link] import classification_report
print(classification_report(y_test, pred))
Regresión
● MAE
● MSE
● RMSE
En R
RMSE <- sqrt(mean((y_test - pred)^2))
En Python
from [Link] import mean_squared_error
rmse = mean_squared_error(y_test, pred, squared=False)