✂️ Paso 1: División de datos para adestramento e test

Antes de nada, debemos dividir os datos que xa temos procesados e escalados (csv - 95303 B) en conxunto de adestramento(train) e conxunto de test. Isto permítenos ensinar ao modelo con unha parte dos datos e despois probar se realmente aprendeu ben con datos novos. Podes facelo con con train_test_split() de Scikit-learn:

from sklearn.model_selection import train_test_split

X = df.drop(columns=['Survived'])  # Variables independentes
y = df['Survived']  # Variable obxectivo

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)    

• Por que é importante ter un conxunto de test separado?
• Que pasa se usamos poucos datos para adestramento?
• Podes visualizar os datos resultantes con X_train.head(5) etc. para comprender ben o proceso

❓ Paso 2: Proba con modelos clásicos

Primeiro probarás modelos clásicos de machine learning como Regresión Loxística, Random Forest e Support Vector Machine (SVM). Estes modelos son rápidos e sinxelos de interpretar.

1. 👉 Regresión Loxística: Modelo moi útil para clasificación binaria (sobrevive ou non).
   

   Código Python: Creación e adestramento do modelo de regresión

   #Isto carga LogisticRegression desde scikit-learn, que usaremos para crear o noso modelo de clasificación.
   from sklearn.linear_model import LogisticRegression
   
   #Este paso elimina todas as columnas con datos en formato texto, xa que LogisticRegression só funciona con números. 
   #Se hai nomes ou categorías en texto, estas deben ser convertidas antes de poder adestrar o modelo.
   #Todavía quedan os nomes das personas e os tickets como texto 'objet' e non as precisamos
   X_train = X_train.select_dtypes(exclude=['object'])
   X_test = X_test.select_dtypes(exclude=['object'])
   
   #Aquí creamos un modelo de regresión loxística e fixamos max_iter=500, o que significa que permitiremos ata 500 iteracións 
   #para que o modelo mellore a súa precisión antes de deter o proceso de adestramento.
   model_lr = LogisticRegression(max_iter=500)
   
   #Nesta liña, o modelo aprende a relacionar as variables independentes (X_train) coa variable obxectivo (y_train). 
   #Está "estudando" os datos para poder facer predicións.
   model_lr.fit(X_train, y_train)  # Adestramento
   
   #Unha vez adestrado, o modelo usa os datos de X_test (que nunca viu antes) para facer predicións sobre y_test. 
   #O resultado y_pred_lr conterá os valores que o modelo cre que son correctos.
   y_pred_lr = model_lr.predict(X_test)  # Predición
       

   Copiar

   O resultado y_pred_lr contén os valores que o modelo cre que son correctos. Agora podes comprobar os resultados e avaliar que tal funciona o modelo. O máis sinxelo e visual é usar a matriz de confusión ou heatmap e a tasa de acertos ou precisión do modelo.

   Código Python: Matriz de confusión e precisión do modelo

   # Importamos as ferramentas necesarias para avaliar o modelo e visualizar a matriz de confusión e a precisión do modelo
   from sklearn.metrics import confusion_matrix  # Para calcular a matriz de confusión
   from sklearn.metrics import accuracy_score  # Para calcular a porcentaxe de acertos do modelo
   import seaborn as sns  # Para xerar gráficos bonitos
   
   # Creamos a matriz de confusión, comparando os valores reais (y_test) coas predicións do modelo (y_pred_lr)
   cm = confusion_matrix(y_test, y_pred_lr)
   
   # Debuxamos a matriz de confusión cun mapa de calor usando Seaborn
   sns.heatmap(cm, annot=True, fmt="d", cmap="Oranges")  # Mostramos os valores no gráfico e escollemos a cor "Oranges"
   
   # Engadimos etiquetas aos eixes para que se entenda ben a visualización
   plt.xlabel("Predición")  # Eixo X = Valores predicidos polo modelo
   plt.ylabel("Real")  # Eixo Y = Valores reais no conxunto de test
   plt.title("Matriz de confusión")  # Título do gráfico
   
   # Mostramos o gráfico na pantalla
   plt.show()
   
   # Comparación entre as predicións feitas polo modelo e os valores reais dos datos de test
   precision = accuracy_score(y_test, y_pred_lr)  # Calcula a precisión do modelo
   
   # Mostramos a precisión obtida, redondeada a dous decimais para mellor visualización
   print(f"Precisión do modelo: {precision:.2f}")  # Exemplo: se a precisión é 0.75, significa que o modelo acerta no 75% dos casos    

   Copiar

2. 👉 Random Forest: Modelo baseado en múltiples árbores de decisión que combina predicións.

   Código Python:Creamos e adestramos o modelo de árbore de decisión

   # Importamos a clase RandomForestClassifier desde sklearn, que permite crear un modelo de bosques aleatorios
   from sklearn.ensemble import RandomForestClassifier  
   
   # Creamos o modelo de Random Forest con 100 árbores de decisión e unha semilla fixa para reproducibilidade
   model_rf = RandomForestClassifier(n_estimators=100, random_state=42)  
   # "n_estimators=100" significa que o modelo terá 100 árbores para tomar decisións en conxunto
   #"random_state=42" garante que a execución sexa reproducible e sempre obtemos os mesmos resultados
   
   # Adestramos o modelo cos datos de entrenamiento (X_train) e a variable obxectivo (y_train)
   model_rf.fit(X_train, y_train)  
   #O modelo aprende a relación entre as características (X_train) e os resultados reais (y_train)
   
   # Facemos predicións cos datos de test (X_test), que nunca antes foron vistos polo modelo
   y_pred_rf = model_rf.predict(X_test)  
   #O modelo usa as regras que aprendeu para prever os valores de y_test
       

   Copiar

   O resultado y_pred_rf contén os valores que o modelo cre que son correctos. Agora podes comprobar os resultados e avaliar que tal funciona o modelo. Volvemos usar a matriz de confusión ou heatmap e a tasa de acertos ou precisión do modelo.

   Código Python: Visualizamos o heatmap do modelo e a súa precisión

   # Creamos a matriz de confusión, comparando os valores reais (y_test) coas predicións do modelo (y_pred_rf)
   cm = confusion_matrix(y_test, y_pred_rf)
   
   # Debuxamos a matriz de confusión cun mapa de calor usando Seaborn
   sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")  # Mostramos os valores no gráfico e escollemos a cor "Blues"
   
   # Engadimos etiquetas aos eixes para que se entenda ben a visualización
   plt.xlabel("Predición")  # Eixo X = Valores predicidos polo modelo
   plt.ylabel("Real")  # Eixo Y = Valores reais no conxunto de test
   plt.title("Matriz de confusión")  # Título do gráfico
   
   # Mostramos o gráfico na pantalla
   plt.show()
   
   # Comparación entre as predicións feitas polo modelo e os valores reais dos datos de test
   precision = accuracy_score(y_test, y_pred_rf)  # Calcula a precisión do modelo
   
   # Mostramos a precisión obtida, redondeada a dous decimais para mellor visualización
   print(f"Precisión do modelo: {precision:.2f}")  # Exemplo: se a precisión é 0.75, significa que o modelo acerta no 75% dos casos    

   Copiar
3. 👉 Support Vector Machine (SVM): Modelo que busca separadores óptimos entre clases. Este modelo é útil para problemas de clasificación binaria ou multi-clase, especialmente cando os datos non son linealmente separables.

   Código Python: Creamos e adestramos o modelo de SVM

   # Importamos a clase SVC (Support Vector Classifier) desde a biblioteca scikit-learn
   from sklearn.svm import SVC  
   
   # Creamos o modelo de SVM (Máquinas de Soporte Vectorial) sen parámetros específicos
   #Probei a introducir axustes nos parámetros model_svm = SVC(C=0.1, class_weight='balanced'), pero non mellora significativamente
   
   model_svm = SVC()
   
    
   #SVM é un algoritmo de clasificación que busca a mellor liña (ou hiperplano) para separar as clases dos datos
   
   # Adestramos o modelo usando os datos de entrenamiento (X_train) e a variable obxectivo (y_train)
   model_svm.fit(X_train, y_train)  
   #O modelo aprende a relación entre as características (X_train) e os resultados reais (y_train)
   #Durante o adestramento, SVM intenta atopar o hiperplano óptimo que mellor separa as clases
   
   # Realizamos predicións sobre os datos de test (X_test), que o modelo nunca viu antes
   y_pred_svm = model_svm.predict(X_test)  
   #O modelo aplica o hiperplano aprendido para predicir se os novos exemplos pertencen á clase 0 ou 1    

   Copiar

   O resultado y_pred_svm contén os valores que o modelo cre que son correctos. Agora podes comprobar os resultados e avaliar que tal funciona o modelo. Volvemos usar a matriz de confusión ou heatmap e a tasa de acertos ou precisión do modelo.

   Código Python: Visualizamos o heatmap do modelo e a súa precisión

   # Creamos a matriz de confusión, comparando os valores reais (y_test) coas predicións do modelo (y_pred_svm)
   cm = confusion_matrix(y_test, y_pred_svm)
   
   # Debuxamos a matriz de confusión cun mapa de calor usando Seaborn
   sns.heatmap(cm, annot=True, fmt="d", cmap="Greens")  # Mostramos os valores no gráfico e escollemos a cor "Greens"
   
   # Engadimos etiquetas aos eixes para que se entenda ben a visualización
   plt.xlabel("Predición")  # Eixo X = Valores predicidos polo modelo
   plt.ylabel("Real")  # Eixo Y = Valores reais no conxunto de test
   plt.title("Matriz de confusión")  # Título do gráfico
   
   # Mostramos o gráfico na pantalla
   plt.show()
   
   # Comparación entre as predicións feitas polo modelo e os valores reais dos datos de test
   precision = accuracy_score(y_test, y_pred_svm)  # Calcula a precisión do modelo
   
   # Mostramos a precisión obtida, redondeada a dous decimais para mellor visualización
   print(f"Precisión do modelo: {precision:.2f}")  # Exemplo: se a precisión é 0.70, significa que o modelo acerta no 70% dos casos    

   Copiar

💡 Preguntas para reflexionar:

• Cales son as vantaxes e desvantaxes de cada modelo?
• Cal é o mellor?

🧠Paso 3: Proba dun modelo de Deep Learning

Probaremos agora unha Rede Neuronal Simple coas librarías TensorFlow/Keras.

Esta librería traballa con todas as columnas de datos á vez , e non acepta datos tipo object. Tes dúas posibilidades:

1. eliminar as columnas Name e Ticket do dataframe, que son as que quedan con formato object, antes de realizar de novo a División dos datos en trainset e dataset 
2. reconvertir os datos de adestramento e test noutros que non teñan xa datos tipo object.

#Instalamos TensorFlow de xeito "silencioso"
!pip install -q tensorflow

# Importamos TensorFlow e Keras para traballar con redes neuronais
import tensorflow as tf
from tensorflow import keras
from keras import layers

# Convertimos os datos a tensores para que tensorflow os comprenda.
# Creo datos novos, para non perder os iniciais.
X_testT = tf.convert_to_tensor(X_test, dtype=tf.float32)
y_testT = tf.convert_to_tensor(y_test, dtype=tf.float32)
X_trainT = tf.convert_to_tensor(X_train, dtype=tf.float32)
y_trainT = tf.convert_to_tensor(y_train, dtype=tf.float32)


#Creamos un modelo de rede neuronal profunda usando o tipo Sequential
model_dl = keras.Sequential([
    # Primeira capa oculta → 16 neuronas, activación ReLU, entrada co número de características
   layers.Dense(16, activation='relu'),

    # Segunda capa oculta → 8 neuronas, activación ReLU, útil para captar patróns máis complexos
    layers.Dense(8, activation='relu'),

    # Capa de saída → 1 neurona, activación Sigmoid para clasificación binaria
    layers.Dense(1, activation='sigmoid')
])

# Compilamos o modelo, definindo como vai aprender
model_dl.compile(
    optimizer='adam',  #  Optimización con Adam, que axusta os pesos eficientemente
    loss='binary_crossentropy',  #  Perda para clasificación binaria
    metrics=['accuracy']  #  Métrica para medir acertos
)

# Adestramos a rede neuronal cos datos de entrenamento e gardamos a historia de perda e precisión
history=model_dl.fit(
    X_trainT, y_trainT,  # Datos de entrada e etiquetas reais
    epochs=30,  #  Número de veces que o modelo aprende cos datos
    batch_size=16,  #  Procesa os datos en grupos de 16 exemplos para máis eficiencia
    validation_data=(X_testT, y_testT)  #  Usa datos de validación para comprobar o rendemento
)
print("Rematou o adestramento do modelo")
y_pred = model_dl.predict(X_testT)  # Executa a predición unha única vez
y_pred_rede = tf.cast((y_pred > 0.5), tf.int32)

# Importamos as ferramentas necesarias para avaliar o modelo e visualizar a matriz de confusión e a precisión do modelo
from sklearn.metrics import confusion_matrix # Para calcular a matriz de confusión
from sklearn.metrics import accuracy_score # Para calcular a porcentaxe de acertos do modelo import seaborn as sns

# Creamos a matriz de confusión, comparando os valores reais (y_testT) coas predicións do modelo (y_pred_rede)
cm = confusion_matrix(y_testT, y_pred_rede)

# Debuxamos a matriz de confusión cun mapa de calor usando Seaborn
sns.heatmap(cm, annot=True, fmt="d", cmap="Greys") # Mostramos os valores no gráfico e escollemos a cor "Greys"

# Engadimos etiquetas aos eixes para que se entenda ben a visualización
plt.xlabel("Predición") # Eixo X = Valores predicidos polo modelo
plt.ylabel("Real") # Eixo Y = Valores reais no conxunto de test
plt.title("Matriz de confusión") # Título do gráfico

# Mostramos o gráfico na pantalla
plt.show()

# Comparación entre as predicións feitas polo modelo e os valores reais dos datos de test
precision = accuracy_score(y_testT, y_pred_rede) # Calcula a precisión do modelo

# Mostramos a precisión obtida, redondeada a dous decimais para mellor visualización
print(f"Precisión do modelo: {precision:.2f}") # Exemplo: se a precisión é 0.5, significa que o modelo acerta no 50% dos casos    

💡 Preguntas para reflexionar:

• Como se diferencia unha rede neuronal doutros modelos?
• Cres que Deep Learning é necesario para este problema ou un modelo clásico pode funcionar ben?

✅ Feito

Agora temos varios modelos de IA adestrados e funcionando! Probastes diferentes técnicas de Machine Learning e incluso unha Rede Neuronal. Calculáchedes o rendemento e precisión de cada unha. Comparáchedes os resultados para poder escoller o mellor modelo.

🚢Xa están listos para predicir a supervivencia no Titanic!