Predicción Lluvia en Australia
Objetivo
La tarea es desarrollar un modelo de aprendizaje que prediga de manera binaria (sí/no) si el día de mañana lloverá (columna RainTomorrow) en una o varias de las ciudades australianas que existen en los datos (columna Location).
Carga librerías
En primer lugar es necesario realizar la instalación y carga de las librerias requeridas para el proyecto.
!pip install geopy==2.2.0
!pip install category_encoders==2.4.0
import numpy as np
import pandas as pd
import geopandas as gpd
import seaborn as sns
import matplotlib.pyplot as plt
from plotly.subplots import make_subplots
import plotly.graph_objects as go
import folium
from folium import Choropleth, Circle, Marker
from folium.plugins import HeatMap, MarkerCluster
from sklearn.model_selection import train_test_split
from geopy.geocoders import Nominatim
import time
import math
import category_encoders as ce
from sklearn.preprocessing import MinMaxScaler
from sklearn.linear_model import LogisticRegression
from sklearn import metrics #Importa metricas scikit-learn para el calculo del accuracy
from sklearn import preprocessing #Importa funciones para el procesamiento de los datos
from sklearn.metrics import confusion_matrix #Importa los métodos de cálculo de la matriz de confusión
from sklearn.metrics import precision_recall_fscore_support # Importa módulos para calcular métricas a partir de la matriz de confusión
from sklearn.tree import DecisionTreeClassifier # Importa el Decision Tree Classifier
from sklearn.metrics import classification_report
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.neural_network import MLPClassifier
Análisis Exploratorio de Datos
A continuación, se cargará la base de datos y empieza la exploración de los datos.
Exploración de los datos
# Importar el dataset (.csv)
rain = pd.read_csv('/work/weatherAUS.csv')
rain.head(5)
#Observar las dimensiones del dataset
rain.shape
El dataset tiene 145460 registros y 23 variables.
#Observar los nombres de las columnas
col_names = rain.columns
col_names
#Observar información general del dataset
rain.info()
Información importante con respecto al dataset: - Hay valores que faltan en el conjunto de datos - El conjunto de datos incluye valores numéricos y categóricos (float64 y object)
#Observar las propiedades estadisticas de las variables numericas del dataset
rain.describe()
#Observar las propiedades estadisticas de las variables categoricas del dataset
rain.describe(include=['object'])
- Existen 16 variables numericas, 7 categoricas y 1 correspondiente a la fecha. - El conjunto de datos incluye valores numéricos y categóricos (float64 y object) - La variable objetivo es RainTomorrow
Se procede a depurar el dataset eliminando los registros con valores faltantes
#Buscar la cantidad de registros con datos faltantes
rain.isnull().sum()
#Remover todas las filas que presenten datos nulos
rain.dropna(subset=['RainTomorrow'],inplace = True)
#rain.reset_index(drop=True,inplace=True)
rain.isnull().sum()
Variable Objetivo
Ahora se observa la variable objetivo
#Frecuencia en la variable objetivo
rain['RainTomorrow'].value_counts()
#Porcentaje de frecuencia en la variable objetivo
rain['RainTomorrow'].value_counts()/len(rain)
#Grafico la frecuencia de la variable objetivo
f, ax = plt.subplots(figsize=(6, 8))
ax = sns.countplot(x="RainTomorrow", data=rain)
plt.show()
Los registros se encuentras distribuidos de la siguiente forma: No=110316(77.5819%) y Yes=31877(22.4181%)
Variables Numericas
numerical = rain.describe().columns
numerical
rain[numerical].head()
rain[numerical].isnull().sum()
rain[numerical].nunique()
Variables Categoricas
categorical = rain.describe(include=['object']).columns
categorical
rain[categorical].head()
rain[categorical].isnull().sum()
Se presentan valores faltantes, por lo tanto es necesario tratarlos.
rain[categorical].nunique()
La variable Date tiene gran cantidad de registros unicos, por lo que es necesario realizar un preprocesamiento.
rain['Date'] = pd.to_datetime(rain['Date'])
rain['Year'] = rain['Date'].dt.year
rain['Month'] = rain['Date'].dt.month
rain['Day'] = rain['Date'].dt.day
rain.drop('Date', axis=1, inplace = True)
fechas = pd.concat([rain['Year'], rain['Month'],rain['Day']], axis=1)
fechas.head()
rain.info()
ciudades = rain.Location.unique()
ciudades
Es necesario convertir variables categoricas en numericas, esto se realiza con el método One Hot Encoding.
pd.get_dummies(rain.Location, drop_first=True).head()
plt.figure(figsize=(20,9))
plt.style.use("default")
plt.title('Locations')
ax = sns.countplot(data=rain, x="Location", color= 'gray')
ax.set_xticklabels(ax.get_xticklabels(), rotation=90)
plt.grid(linewidth = 0.7)
plt.show()
pd.get_dummies(rain.WindGustDir, drop_first=True).head()
plt.figure(figsize=(12,6))
plt.style.use("default")
plt.title('WindGustDir')
ax = sns.countplot(data=rain, x="WindGustDir", color= 'gray')
ax.set_xticklabels(ax.get_xticklabels())
plt.grid(linewidth = 0.7)
plt.show()
pd.get_dummies(rain.WindDir9am, drop_first=True).head()
plt.figure(figsize=(12,6))
plt.style.use("default")
plt.title('WindDir9am')
ax = sns.countplot(data=rain, x="WindDir9am", color= 'gray')
ax.set_xticklabels(ax.get_xticklabels())
plt.grid(linewidth = 0.7)
plt.show()
pd.get_dummies(rain.WindDir3pm, drop_first=True).head()
plt.figure(figsize=(12,6))
plt.style.use("default")
plt.title('WindDir3pm')
ax = sns.countplot(data=rain, x="WindDir3pm", color= 'gray')
ax.set_xticklabels(ax.get_xticklabels())
plt.grid(linewidth = 0.7)
plt.show()
pd.get_dummies(rain.RainToday, drop_first=True).head()
Se observa una cantidad de registros uniforme con respecto a las diferentes variables visualizadas.
Visualización efectiva de Datos
#Mostrar el tamaño del dataset filtrado con el que se va a trabajar el proyecto
fig = make_subplots(rows=1, cols=2)
fig.add_trace(go.Indicator(mode = "number", value = rain.shape[0], number={'font':{'color': '#E58F65','size':100}}, title = {"text": "🧾 Rows<br><span style='font-size:0.8em;color:gray'>In the Dataframe</span>"}, domain = {'x': [0, 0.5], 'y': [0.6, 1]}))
fig.add_trace(go.Indicator(mode = "number", value = rain.shape[1], number={'font':{'color': '#E58F65','size':100}}, title = {"text": "⭕ Columns<br><span style='font-size:0.8em;color:gray'>In the Dataframe</span>"}, domain = {'x': [0.5, 1], 'y': [0, 0.4]}))
fig.show()
¿Donde están ubicadas los registros en Australia?
# Crear Objeto Nominatim
from geopy.geocoders import Nominatim
geolocator = Nominatim(user_agent="AppMap")
location_lista = ['Albury','Badgerys Creek','Cobar','Coffs Harbour','Moree','Newcastle','Norah Head','Norfolk Island','Penrith',
'Richmond','Sydney','Sydney Airport','Wagga Wagga','Williamtown','Wollongong','Canberra','Tuggeranong','Mount Ginini','Ballarat',
'Bendigo','Sale','Melbourne Airport','Melbourne','Mildura','Nhil','Portland','Watsonia','Dartmoor','Brisbane','Cairns','GoldCoast',
'Townsville','Adelaide','Mount Gambier','Nuriootpa','Woomera','Albany','Witchcliffe','Pearce RAAF','Perth Airport','Perth','SalmonGums',
'Walpole','Hobart','Launceston','Alice Springs','Darwin','Katherine','Uluru']
#Se obtienen las coordenadas de las locaciones
latitud = []
longitud = []
#Recorremos la lista
for i in location_lista:
address = geolocator.geocode(i, timeout=10)
if address is not None:
ciudad = location_lista
latitud.append(address.latitude)
longitud.append(address.longitude)
else:
print(f"Could not find Location for {address!r}")
# extrayendo los valores de longitud y latitud a listas separadas
longs = longitud
lats = latitud
# crear un objeto mapa base usando Map()
mapa_aus = folium.Map(location=[-24.89611610752976, 133.54713377264966], zoom_start = 4)
# crear capa de mapa de calor
heatmap = HeatMap( list(zip(lats, longs)),
min_opacity=0.5,
radius=50, blur=50,
max_zoom=1)
# añadir capa de mapa de calor al mapa base
heatmap.add_to(mapa_aus)
mapa_aus
Mapa de Calor Correlacion Dataset Lluvia en Australia
#Se observa que tan correlacionadas están las variables del dataset
correlation = rain[numerical].corr()
plt.figure(figsize=(16,12))
plt.title('Mapa de Calor Correlacion Dataset Lluvia en Australia')
ax = sns.heatmap(correlation, square=True, annot=True, fmt='.2f', linecolor='white')
ax.set_xticklabels(ax.get_xticklabels(), rotation=90)
ax.set_yticklabels(ax.get_yticklabels(), rotation=30)
plt.show()
Las variables que mayor correlación presentan son: [MinTemp, MaxTemp, Temp9am, Temp3pm, WindGustSpeed, WindSpeed3pm, Pressure9am, Pressure3pm. Por serán graficadas para observar su comportamiento.
corr_var = ['MinTemp', 'MaxTemp', 'Temp9am', 'Temp3pm', 'WindGustSpeed', 'WindSpeed3pm', 'Pressure9am', 'Pressure3pm']
sns.pairplot(rain[corr_var], kind='scatter', diag_kind='hist', palette='Rainbow')
plt.show()
plt.figure(figsize=(10,10))
plt.title('Distribucion de Variables con alta Correlación')
plt.subplot(2, 4, 1)
sns.distplot(rain['MinTemp'])
plt.subplot(2, 4, 2)
sns.distplot(rain['MaxTemp'])
plt.subplot(2, 4, 3)
sns.distplot(rain['Temp9am'])
plt.subplot(2, 4, 4)
sns.distplot(rain['Temp3pm'])
plt.subplot(2, 4, 5)
sns.distplot(rain['WindGustSpeed'])
plt.subplot(2, 4, 6)
sns.distplot(rain['WindSpeed3pm'])
plt.subplot(2, 4, 7)
sns.distplot(rain['Pressure9am'])
plt.subplot(2, 4, 8)
sns.distplot(rain['Pressure3pm'])
Ingeniería de características
En esta etapa se procede a adecuar los datos para ser utilizados adecuadamente en la generación de diferentes modelos.
Variables Numericas
Se presentan valores faltantes, por lo tanto es necesario tratarlos.
for i in rain:
if rain[i].dtype=='float64':
rain[i].replace(to_replace=np.nan, value=rain[i].median(), inplace=True)
rain[numerical].isnull().sum()
Ahora se buscan los posibles Outliers presentes en las variables numericas
#Se analizan visualmente las variables para observar posibles outliers
plt.figure(figsize=[15,6])
plt.title('Boxplot con outliers')
rain.boxplot(column= ['MinTemp', 'MaxTemp', 'Rainfall', 'Evaporation', 'Sunshine', 'WindGustSpeed', 'WindSpeed9am', 'WindSpeed3pm', 'Humidity9am', 'Humidity3pm', 'Pressure9am', 'Pressure3pm', 'Cloud9am', 'Cloud3pm', 'Temp9am', 'Temp3pm'])
plt.xticks(rotation=45)
plt.show()
#Se eliminan los outliers, datos que están fuera del limite superior e inferior del boxplot.
for i in rain:
if rain[i].dtype=='float64':
Q1 = rain[i].quantile(0.25)
Q3 = rain[i].quantile(0.75)
IQR = Q3-Q1
lower = Q1 - 1.5 * IQR
upper = Q3 + 1.5 * IQR
mediana = np.median(rain[i])
for m in rain[i]:
if m > upper or m < lower:
rain[i] = rain[i].replace(m, mediana)
#Se analizan observa la eliminación de los outliers
plt.figure(figsize=[15,6])
plt.title('Boxplot sin outliers')
rain.boxplot(column= ['MinTemp', 'MaxTemp', 'Rainfall', 'Evaporation', 'Sunshine', 'WindGustSpeed', 'WindSpeed9am', 'WindSpeed3pm', 'Humidity9am', 'Humidity3pm', 'Pressure9am', 'Pressure3pm', 'Cloud9am', 'Cloud3pm', 'Temp9am', 'Temp3pm'])
plt.xticks(rotation=45)
plt.show()
Variables Categoricas
rain['WindGustDir'].fillna(rain['WindGustDir'].mode()[0], inplace=True)
rain['WindDir9am'].fillna(rain['WindDir9am'].mode()[0], inplace=True)
rain['WindDir3pm'].fillna(rain['WindDir3pm'].mode()[0], inplace=True)
rain['RainToday'].fillna(rain['RainToday'].mode()[0], inplace=True)
rain.isnull().sum()
rain.describe()
ce_bin = ce.BinaryEncoder(cols=['RainToday'])
rain = ce_bin.fit_transform(rain)
rain
rain_final = pd.concat([rain[numerical], rain[['RainToday_0', 'RainToday_1']],
pd.get_dummies(rain.Location),
pd.get_dummies(rain.WindGustDir),
pd.get_dummies(rain.WindDir9am),
pd.get_dummies(rain.WindDir3pm),
rain.RainTomorrow], axis=1)
rain_final.head(20)
rain_final.shape
#Mostrar el tamaño del dataset filtrado con el que se va a trabajar el proyecto
fig = make_subplots(rows=1, cols=2)
fig.add_trace(go.Indicator(mode = "number", value = rain_final.shape[0], number={'font':{'color': '#E58F65','size':100}}, title = {"text": "🧾 Rows<br><span style='font-size:0.8em;color:gray'>In the Dataframe</span>"}, domain = {'x': [0, 0.5], 'y': [0.6, 1]}))
fig.add_trace(go.Indicator(mode = "number", value = rain_final.shape[1], number={'font':{'color': '#E58F65','size':100}}, title = {"text": "⭕ Columns<br><span style='font-size:0.8em;color:gray'>In the Dataframe</span>"}, domain = {'x': [0.5, 1], 'y': [0, 0.4]}))
fig.show()
Modelado
Se definen las variables de entrada y salida a utilizar con los algoritmos
#Selecciono mi variable objetivo y sus predictores
X = rain_final.drop(['RainTomorrow'], axis=1)
y = rain_final['RainTomorrow']
X.head()
X.shape
nombre_columnas = X.columns
nombre_columnas
#Divido el conjunto de datos en prueba y entrenamiento
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0, shuffle = False)
#Observo el tamaño de los conjuntos de datos
X_train.shape, X_test.shape, y_train.shape, y_test.shape
X_train
X_test
y_train
y_test
minmax = MinMaxScaler()
X_train = minmax.fit_transform(X_train)
X_train = pd.DataFrame(X_train,columns=[nombre_columnas])
X_train
X_test = minmax.transform(X_test)
X_test = pd.DataFrame(X_test,columns=[nombre_columnas])
X_test
X_train.describe()
X_test.describe()
Se utilizarán diferentes técnicas de aprendizaje automático supervisado con el mismo conjunto de entrenamiento y prueba, esto con el fin de contrastar cual técnica tuvo mejor desempeño realizando la predicción binaria.
Regresión Logistica
#Crear modelo de regresion logistica
regresion_logistica = LogisticRegression(solver='liblinear', random_state=0)
# Entrenar el modelo
regresion_logistica.fit(X_train, y_train)
#Predecir la variable objetivo en los datos de prueba (probar el modelo)
y_pred = regresion_logistica.predict(X_test)
print("Accuracy: \n",metrics.accuracy_score(y_test, y_pred))
#Accuracy, permite identificar qué tan confiable es el modelo. Qué tantas predicciones correctas realizó?
#Se compara el valor original en y_test con el valor predicho en y_pred
print("Matriz de confusión: \n", confusion_matrix(y_test, y_pred))
print("Matriz de confusión normalizada: \n", confusion_matrix(y_test, y_pred, normalize="true"))
tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()
print("TN,FP,FN,TP \n", (tn, fp, fn, tp))
# Ahora calcularemos las métricas derivadas de la matriz de confusión
print("Precision, recall y fscore (por clase): \n",precision_recall_fscore_support(y_test, y_pred, average=None)) # Calcula las métricas por cada clase
print("Precision, recall y fscore (macro): \n",precision_recall_fscore_support(y_test, y_pred, average='macro')) # Cada clase tiene un peso igual, se saca el promedio de la métrica
print("Precision, recall y fscore (micro): \n",precision_recall_fscore_support(y_test, y_pred, average='micro')) # Cada registro (ejemplo) tiene un peso igual
print("Precision, recall y fscore (weighted): \n",precision_recall_fscore_support(y_test, y_pred, average='weighted')) # Se normaliza según el peso de cada clase
# Ahora calcularemos las métricas derivadas de la matriz de confusión
print(classification_report(y_test, y_pred))
Árboles de Decisión
#Crear el Árbol de decisión
clf = DecisionTreeClassifier(random_state=0, max_depth=3)
# Entrenar el árbol de decisión
clf = clf.fit(X_train,y_train)
#Predecir la variable objetivo en los datos de prueba (probar el modelo)
y_pred = clf.predict(X_test)
print("Accuracy: \n",metrics.accuracy_score(y_test, y_pred))
# Accuracy, permite identificar qué tan confiable es el modelo.
#Qué tantas predicciones correctas realizó? Se compara el valor original en y_test con el valor predicho en y_pred
print("Matriz de confusión: \n", confusion_matrix(y_test, y_pred))
print("Matriz de confusión normalizada: \n", confusion_matrix(y_test, y_pred, normalize="true"))
tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()
print("TN,FP,FN,TP \n", (tn, fp, fn, tp))
# Ahora calcularemos las métricas derivadas de la matriz de confusión
print(classification_report(y_test, y_pred))
#Función para optimizar los parámetros de un árbol de decisión
def dtree_grid_search(X,y,nfolds):
#crear un diccionario con todos los valores que se quieren probar
max_depth = 3
minsamplesplit = 3
minsampleleaf = 3
param_grid = {"max_depth": list(range(1, max_depth+1)),
"min_samples_split": list(range(1, minsamplesplit+1)),
"min_samples_leaf": list(range(1, minsampleleaf+1))}
# Crear el objeto árbol de decisión
dtree_model=DecisionTreeClassifier()
#use gridsearch para probar todos los valores
dtree_gscv = GridSearchCV(dtree_model, param_grid, cv=nfolds ,n_jobs=-1)
#entrenaremos
dtree_gscv.fit(X, y)
return dtree_gscv.best_params_
#Acá llamaremos la función para calcular los mejores parámetros
bestparam = dtree_grid_search(X_train,y_train,10)
print ("Los mejores parámetros son", bestparam)
# Crear el árbol de decisión con los mejores parámetros el ** es para desempaquetar el objeto dict (diccionario).
clf = DecisionTreeClassifier(**bestparam, random_state=0, class_weight="balanced")
# Entrenar el árbol
clf = clf.fit(X_train,y_train)
#Predecir los valores del conjunto de entrenamiento
y_pred = clf.predict(X_test)
# Calcular el accuracy
print("Accuracy:", metrics.accuracy_score(y_test, y_pred))
Bosques Aleatorios
# Crear el clasificador
rforest = RandomForestClassifier(n_estimators=20, n_jobs=-1, random_state=0)
# Entrenar el Random Forest
rforest.fit(X_train, y_train)
#Predecir la variable objetivo en los datos de prueba (probar el modelo)
y_pred = rforest.predict(X_test)
print("Accuracy: \n",metrics.accuracy_score(y_test, y_pred))
# Accuracy, permite identificar qué tan confiable es el modelo. Qué tantas predicciones correctas realizó? Se compara el valor original en y_test con el valor predicho en y_pred
print("Accuracy: \n",metrics.accuracy_score(y_test, y_pred))
print("Matriz de confusión: \n", confusion_matrix(y_test, y_pred))
print("Matriz de confusión normalizada: \n", confusion_matrix(y_test, y_pred, normalize="true"))
tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()
print("TN,FP,FN,TP \n", (tn, fp, fn, tp))
# Ahora calcularemos las métricas derivadas de la matriz de confusión
print("Precision, recall y fscore (por clase): \n",precision_recall_fscore_support(y_test, y_pred, average=None)) # Calcula las métricas por cada clase
print("Precision, recall y fscore (macro): \n",precision_recall_fscore_support(y_test, y_pred, average='macro')) # Cada clase tiene un peso igual, se saca el promedio de la métrica
print("Precision, recall y fscore (micro): \n",precision_recall_fscore_support(y_test, y_pred, average='micro')) # Cada registro (ejemplo) tiene un peso igual
print("Precision, recall y fscore (weighted): \n",precision_recall_fscore_support(y_test, y_pred, average='weighted')) # Se normaliza según el peso de cada clase
#Función para optimizar los parámetros de los bosques aleatorios
def rforest_grid_search(X,y,nfolds):
#crear un diccionario con todos los valores que se quieren probar
param_grid = {"max_depth": [5,20],"min_samples_split": [5,10],
"min_samples_leaf": [5,10],"n_estimators": [5,10]}
# Crear el objeto árbol de decisión
rforest_model=RandomForestClassifier()
#use gridsearch para probar todos los valores
rforest_gscv = GridSearchCV(rforest_model, param_grid, cv=nfolds ,n_jobs=-1)
#entrenaremos
rforest_gscv.fit(X, y)
return rforest_gscv.best_params_
#Acá llamaremos la función para calcular los mejores parámetros
bestparam_rforest = rforest_grid_search(X_train,y_train,10)
print ("Los mejores parámetros son", bestparam_rforest)
# Crear el árbol de decisión con los mejores parámetros el ** es para desempaquetar el objeto dict (diccionario).
rforest = RandomForestClassifier(**bestparam_rforest, random_state=0)
# Entrenar el árbol
rforest = rforest.fit(X_train,y_train)
#Predecir la variable objetivo en los datos de prueba (probar el modelo)
y_pred = rforest.predict(X_test)
# Calcular el accuracy
print("Accuracy:", metrics.accuracy_score(y_test, y_pred))
Redes Neuronales
#Crear la red neuronal
modelMLP = MLPClassifier(random_state=0, max_iter=10)
# Entrenar la red neuronal
modelMLP = modelMLP.fit(X_train,y_train)
#Predecir la variable objetivo en los datos de prueba (probar el modelo)
y_pred = modelMLP.predict(X_test)
print("Accuracy: \n",metrics.accuracy_score(y_test, y_pred))
# Accuracy, permite identificar qué tan confiable es el modelo. Qué tantas predicciones correctas realizó? Se compara el valor original en y_test con el valor predicho en y_pred
print("Accuracy: \n",metrics.accuracy_score(y_test, y_pred))
print("Matriz de confusión: \n", confusion_matrix(y_test, y_pred))
print("Matriz de confusión normalizada: \n", confusion_matrix(y_test, y_pred, normalize="true"))
tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()
print("TN,FP,FN,TP \n", (tn, fp, fn, tp))
# Ahora calcularemos las métricas derivadas de la matriz de confusión
print("Precision, recall y fscore (por clase): \n",precision_recall_fscore_support(y_test, y_pred, average=None)) # Calcula las métricas por cada clase
print("Precision, recall y fscore (macro): \n",precision_recall_fscore_support(y_test, y_pred, average='macro')) # Cada clase tiene un peso igual, se saca el promedio de la métrica
print("Precision, recall y fscore (micro): \n",precision_recall_fscore_support(y_test, y_pred, average='micro')) # Cada registro (ejemplo) tiene un peso igual
print("Precision, recall y fscore (weighted): \n",precision_recall_fscore_support(y_test, y_pred, average='weighted')) # Se normaliza según el peso de cada clase
Métricas de Desempeño
Con los resultados obtenidos al predecir la variable objetivo en los datos de prueba se calcula qué tan bien o mal hizo la predección el modelo. La medición de errores y aciertos es usado para obtener varias métricas.
En este caso se toma como métrica principal el Accuracy, obteniendo los siguientes resultados: - Regresión Logística: 0.8586 - Árboles de Decisión: 0.8438 - Árboles de Decisión Optimizado: 0.8276 - Bosques Aleatorios: 0.8518 - Bosques Aleatorios Optimizado: 0.8534 - Redes Neuronales: 0.8537
Conclusiones
- Las 4 técnicas utilizadas predijeron con buen desempeño si en una o varias de las ciudades australianas que existen en los datos lloverá. - Al sur oriente del país es donde se encuentra la mayor cantidad de locaciones donde fueron tomados los registros del dataset. - La optimización de parámetros no siempre mejora los desempeños, es necesario realizar una búsqueda con mayor alcance.
Observaciones
- La optimización de parámetros no fue más exhaustiva por falta de poder de cómputo. - En trabajos futuros podrían utilizarse diferentes conjuntos de características para el modelado. - Aplicar técnicas diferentes a las utilizadas en este trabajo. Estas observaciones abren la posibilidad a encontrar mejores desempeños, por lo tanto, cumplir con el objetivo deseado.