📂 Paso 1: Selección de datos e modelo para predicir

Os vosos modelos agora poden facer predicións sobre novos datos. É o momento de probalos con datos de test!

Para iso precisas tomar un par de decisións, e ter no teu novo caderno de Colab:

• O Modelo creado e adestrado que decidiras usar Regresión, Random Forest, SVM ou rede neuronal. Decido usar o modelo de Random Forest, xa que foi o que mellor resultados obtivo na Actividade 4.
• Os Datos de test : Podes seguir usando os que separamos no paso 1 da Actividade 4, ou descargar de kaggle un testset novo e procesar os datos novos como fixeches na Actividade 2, para escalalos e normalizalos. Imos realizalo dos dous xeitos

🔮 Paso 2: Realizando predicións cos datos test usados previamente

Usando o arquivo de datos procesado datasetTitanicProcesado (csv - 95303 B) co dataset(X_test e y_test) que xa tiñamos para validar e probar os modelos (máis sinxelo, xa que xa os temos escalados e normalizados):

import pandas as pd # Incluímos pandas para traballar con datos
import numpy as np #numpy para facer contas
import matplotlib.pyplot as plt
import seaborn as sns    #E matplotlib e seaborn para gráficos
# Ruta do ficheiro en Colab, tes que telo subido en arquivos, e cambia o nome se lle tes un distinto
df = pd.read_csv("/content/datasetTitanicProcesado.csv")
# Eliminar a columna Nome e Ticket porque ten valores object que non nos interesan para o proxecto,
# podemos sempre localizar á persona co seu PassengerId
df = df.drop(columns=['Name','Ticket'])

#Dividimos dataset
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)
y_test.info() # Mostra as 10 primeiras filas do DataFrame DESPÓS DO CORTE    

Volves crear e adestrar o modelo tal como xa fixeches na Actividade 4.

# Importamos a clase RandomForestClassifier desde sklearn, que permite crear un modelo de árbores 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, gárdaos en y_pred_rf
    

Agora compararás os valores que predí o modelo, cos reais e resaltarás os erros en vermello

y_pred = y_pred_rf  # Cambiar polo modelo que queiras usar


# Creamos o DataFrame cos valores reais e predicións
df_comparacion = pd.DataFrame({
    "Valor Real": y_test[:179],  # Os 179 valores reais de test, podes poñer menos, ése é o máximo que ten
    "Predición Modelo": y_pred[:179]  # As 179 predicións do modelo
})

# Función para aplicar estilos á columna de predicións e destacar en vermello os erros
def destacar_diferenzas(value, real_values):
    return 'color: green' if value == real_values else 'color: red'

# Aplicamos estilos usando apply() para cada fila
df_comparacion_style = df_comparacion.style.apply(
    lambda row: ['color: green' if row["Predición Modelo"] == row["Valor Real"] else 'color: red'] * len(row),
    axis=1
)
df_comparacion_style    

Obtés así unha táboa cos datos, nos que se destaca donde errou o modelo. Agora podes calcular cantos erros cometeu , o % de acertos, e graficalo.

# Contamos os erros (predicións incorrectas)
erros = (df_comparacion["Predición Modelo"] != df_comparacion["Valor Real"]).sum()

# Mostramos o número total de erros
print(f"Total de erros: {erros}")

# Total de predicións
total_predicions = len(df_comparacion)

# Total de acertos (cando Predición Modelo = Valor Real)
acertos = (df_comparacion["Predición Modelo"] == df_comparacion["Valor Real"]).sum()

# Calculamos a precisión en porcentaxe
precision = (acertos / total_predicions) * 100

# Mostramos o resultado
print(f"Precisión do modelo: {precision:.2f}%")
# Creamos a gráfica
plt.bar(["Acertos", "Erros"], [acertos, erros], color=["green", "red"])
plt.ylabel("Número de casos")
plt.title("Comparación de acertos e erros")
plt.show()    

🔮🛠️ Paso 3: Realizando predicións con datos test totalmente novos descargados de internet

1. Vai a Kaggle e descarga o arquivo Titanic Dataset.csv. Este arquivo contén 1307 datos(o anterior que usamos, tiña 891). Conseguiremos así 416 datos reais novos. No arquivo Titanic Dataset.csv hai algunhas columnas finais que non nos interesan e debes cambiar os nomes das columnas para que sexan idénticas ó que tiñas. Consegues así o arquivo Titanic Dataset1307.csv (csv - 87623 B) listo para usar.
2. Agora debes extraer aqueles datos distintos ós usados, e crear un novo arquivo cos 416 datos novos. Podes facelo con este código e usando os dous arquivos trainTitanic891.csv (csv - 61085 B) e o de 1307 datos. No menú da esquerda do teu caderno de Colab, fai clic en Arquivos (icono de carpeta).Fai clic en Subir e selecciona o ficheiro trainTitanic891.csv(ou o nome co que o gardaras).csv e Titanic Dataset1307.csv desde o teu computador. Se precisas volver acceder ao ficheiro despois de pechar Colab, terás que subilo de novo, porque os ficheiros cargados non se gardan permanentemente.

   Código Python: Conseguir o arquivo con datos distintos ós usados filtrando por nome da persona

   import pandas as pd
   import seaborn as sns    #E seaborn para gráficos
   import numpy as np #numpy para facer contas
   import matplotlib.pyplot as plt
   
   # Carga os arquivos CSV
   df1 = pd.read_csv("/content/trainTitanic891.csv")
   df2 = pd.read_csv("/content/Titanic Dataset1307.csv")
   
   # Extrae a columna 'Name'
   names1 = set(df1["Name"])
   names2 = set(df2["Name"])
   
   # Obtén os nomes que están en só un dos arquivos
   names_unicos = names1.symmetric_difference(names2)
   
   # Filtra os datos que conteñen só os nomes únicos
   df_unico1 = df1[df1["Name"].isin(names_unicos)]
   df_unico2 = df2[df2["Name"].isin(names_unicos)]
   
   # Unimos os resultados
   df_final = pd.concat([df_unico1, df_unico2])
   
   # Xera os valores de PassengerId desde 892 ata 1307 xa que o proceso anterior fai que aparezan baleiros
   df_final["PassengerId"] = range(892, 1308)  # O último número debe ser 1308 para incluír 1307
   
   # Gardamos o resultado nun novo CSV
   df_final.to_csv("DatosTitanicNovos416.csv", index=False)
   
   print("Arquivo xerado con éxito: DatosTitanicNovos416.csv")
   df = pd.read_csv("/content/DatosTitanicNovos416.csv")  # Ruta do ficheiro en Colab
   df.head(5)  # Mostra as 5 primeiras filas do DataFrame    

   Copiar
3. Toca, como xa sabes, procesar os valores nulos, aquelas columnas que non nos serven para o proxecto, escalar e normalizar os datos do mesmo xeito que fixeches na Actividade 2. Executa  df.isnull().sum(). Indica que hai valores nulos en Cabin 325, Age 86 e Fare 1. As columnas Name e Ticket demostraron non ser relevantes, elimina ambas.

   Código Python: Procesado de valores nulos e columnas categóricas non relevantes

   # Substituír os valores nulos en Age e Fare pola media
   df['Age'] = df['Age'].fillna(round(df['Age'].mean(),2))
   df['Fare'] = df['Fare'].fillna(round(df['Fare'].mean(),2))
   
   # Substituír valores nulos en Embarked pola categoría máis común
   df['Embarked'] = df['Embarked'].fillna(df['Embarked'].mode()[0])
   
   # Eliminar a columna Cabin porque ten demasiados valores nulos e Name e Ticket porque non nos fan falla e son categóricos
   df = df.drop(columns=['Cabin','Name','Ticket'])
   
   # Verificar os cambios
   print(df.isnull().sum())  # Comprobar que xa non hai valores nulos en Age e Embarked
   df.head(5)  # Mostra as 5 primeiras filas do DataFrame    

   Copiar

   Procesa Sex e Embarked para que teñan valores bool True e False, eliminando o terceiro valor do embarque por redundancia.

   Código Python: Procesado de columnas categóricas

   df = pd.get_dummies(df, columns=['Sex', 'Embarked'], drop_first=True)
   df.info()
   df.head(5)  # Mostra as 5 primeiras filas do DataFrame    

   Copiar

   Escala Age e Fare, co mesmo método que na Actividade 2.

   Código Python: Escalado de datos

   from sklearn.preprocessing import StandardScaler
   scaler = StandardScaler()
   
   df[['Age', 'Fare']] = scaler.fit_transform(df[['Age', 'Fare']]) # Escalado desas 2 columnas
   df.head(5) # Mostra as 5 primeiras filas do DataFrame DESPÓS DO ESCALADO    

   Copiar
4. Vas a crear o novo conxunto de datos para probar o modelo previamente adestrado cos antiguos(trainTitanic891.csv). Conseguiremos 2 arquivos X_testNOVO con todos os datos salvo a información de supervivencia e y_testNOVO só co PassengerId e Survived. Podes visualizalos ó rematar con X_testNOVO.head(5) e y_testNOVO.head(5).

   Código Python: Obter X_testNOVO e y_testNOVO para probar o modelo adestrado

   # Creamos X_testNOVO con todos os datos salvo "Survived"
   X_testNOVO = df.drop(columns=["Survived"])
   
   # Creamos y_testNOVO con "PassengerId" e "Survived"
   y_testNOVO = df[["PassengerId", "Survived"]]
   
   # Opcional: gardamos os novos DataFrames en CSV se o necesitas
   #X_testNOVO.to_csv("X_testNOVO.csv", index=False)
   #y_testNOVO.to_csv("y_testNOVO.csv", index=False)
   
   print("Arquivos X_testNOVO.csv e y_testNOVO.csv creados con éxito!")    

   Copiar
5. (Feito na Actividade 4)Volve usar train DatosTitanicProcesado.csv (csv - 95303 B), dividímolo en train e test para adestrar o modelo de Random Forest

   Código Python: Datos para adestrar o modelo

   # Ruta do ficheiro en Colab, tes que telo subido en arquivos, e cambia o nome se lle tes un distinto
   df = pd.read_csv("/content/datasetTitanicProcesado.csv")
   # Eliminar a columna Nome e Ticket porque ten valores object que non nos interesan para o proxecto, 
   # podemos sempre localizar á persona co seu PassengerId
   df = df.drop(columns=['Name','Ticket'])
   from sklearn.model_selection import train_test_split
   
   X_iniciais = df.drop(columns=['Survived'])  # Variables independentes
   y_iniciais = df['Survived']  # Variable obxectivo
   
   X_train, X_test, y_train, y_test = train_test_split(X_iniciais, y_iniciais, test_size=0.2, random_state=42)    

   Copiar
6. (Feito na Actividade 4)Crea  e adestra o modelo, facéndolle ó final, predicir X_testNOVO

   Código Python: Adestramento cos datos antiguos(891) e predicióncos novos(416) do modelo Random Forest

   # 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 NOVOS (X_testNOVO), que nunca antes foron vistos polo modelo
   y_pred_rf = model_rf.predict(X_testNOVO)
   #O modelo usa as regras que aprendeu para prever os valores de y_testNOVO
   #print(y_pred_rf) se queremos ver os datos preditos
   #print(y_testNOVO) se queremos ver os datos reais    

   Copiar
7. Compara a realidade co valor predito e imprime resaltando os erros

   Código Python: Acertou o modelo?

   y_pred = y_pred_rf  # Cambiar polo modelo que queirades usar
   y_test = y_testNOVO["Survived"] #collemos só a columna Survived do y_testNOVO para comparalo con y_pred
   
   # Creamos o DataFrame cos valores reais e predicións
   df_comparacion = pd.DataFrame({
       #"PassengerId": y_testNOVO["PassengerId"][:416],  #Se queres ver tamén estes datos
       #"Name":X_testNOVOENTEIRO["Name"][:416],
       # "Pclass":X_testNOVO["Pclass"][:416],
       "Valor Real": y_test[:416].astype(int),  # Cos 416 valores reais de test
       "Predición Modelo": y_pred[:416]  # Coas 418 predicións do modelo
   })
   
   # Función para aplicar estilos á columna de predicións e destacar en vermello os erros
   def destacar_diferenzas(value, real_values):
       return 'color: green' if value == real_values else 'color: red'
   
   # Aplicamos estilos usando apply() para cada fila
   df_comparacion_style = df_comparacion.style.apply(
       lambda row: ['color: green' if row["Predición Modelo"] == row["Valor Real"] else 'color: red'] * len(row),
       axis=1)
   
   df_comparacion_style    

   Copiar
8. Contabiliza os erros e acertos, para comprobar a fiabilidade do modelo

   Código Python: Erros e acertos.Fiabilidade da predición do modelo.

   # Contamos os erros (predicións incorrectas)
   erros = (df_comparacion["Predición Modelo"] != df_comparacion["Valor Real"]).sum()
   
   # Mostramos o número total de erros
   print(f"Total de erros: {erros}")
   
   # Total de predicións
   total_predicions = len(df_comparacion)
   
   # Total de acertos (cando Predición Modelo = Valor Real)
   acertos = (df_comparacion["Predición Modelo"] == df_comparacion["Valor Real"]).sum()
   
   # Calculamos a precisión en porcentaxe
   precision = (acertos / total_predicions) * 100
   
   # Mostramos o resultado
   print(f"Precisión do modelo: {precision:.2f}%")
   # Contamos acertos e erros
   erros = (df_comparacion["Predición Modelo"] != df_comparacion["Valor Real"]).sum()
   acertos = (df_comparacion["Predición Modelo"] == df_comparacion["Valor Real"]).sum()
   
   # Creamos a gráfica
   plt.bar(["Acertos", "Erros"], [acertos, erros], color=["green", "red"])
   plt.ylabel("Número de casos")
   plt.title("Comparación de acertos e erros")
   plt.show()    

   Copiar

👉 Paso 4: Queres máis?

Sempre hai formas de mellorar un modelo. Pensa en como podes optimizalo:

• Engadir máis datos: Se tivésemos máis información dos pasaxeiros, poderiamos facer mellores predicións. Podes realizar o adestramento e proba co arquivo de 1307 datos
• Probar con diferentes algoritmos: Podes probar con redes neuronais ou regresión 
• Optimizar hiperparámetros: Axustar detalles no modelo pode marcar a diferenza en precisión. Busca que parámetros podes cambiar en cada algoritmo e proba a eficacia dos cambios.

✅ Feito

Completastes o voso primeiro  proxecto de IA! Aplicastes todo o que aprendestes e fixéstelo coma profesionais de datos.

 Agora pensa:

• O voso modelo é útil e preciso?
• Que aprendeches con este proceso?
• Como mellorarías o proxecto se tivéses máis tempo?
• Con que outros datos poderías realizar un novo proxecto? Metereoloxía? Mediciña? A túa viaxe na IA só acaba de empezar!

 Fantástico traballo!

Seguide experimentando, mellorando e creando!