Este artículo es una continuación del artículo anterior en una serie de tres partes sobre el uso del Machine Learning en Python para predecir las temperaturas climáticas para la ciudad de Lincoln, Nebraska en los Estados Unidos, según los datos recopilados de los servicios API de Weather Underground.
En el primer artículo de la serie, Uso del Machine Learning para predecir el clima: Parte 1, describí cómo extraer los datos de Weather Underground, analizarlos y limpiarlos. Para obtener un resumen de los temas de cada uno de los artículos presentados en esta serie, consulte la introducción del artículo anterior.
El enfoque de este artículo será describir los procesos y pasos necesarios para construir un modelo de Regresión lineal riguroso para predecir los valores de temperatura diaria promedio futuros basados en el conjunto de datos construido en el artículo anterior. Para construir el modelo de regresión lineal, demostraré el uso de dos bibliotecas de Python importantes en la industria del Machine Learning: Scikit-Learn y StatsModels .
En el tercer artículo de la serie, Uso del Machine Learning para predecir el clima: Parte 3, describo los procesos y pasos necesarios para construir una red neuronal utilizando TensorFlow de Google para predecir las temperaturas medias diarias futuras. Usando este método, puedo comparar los resultados con el modelo de regresión lineal.
Volver a familiarizarnos con el conjunto de datos
Contenido
- 1 Volver a familiarizarnos con el conjunto de datos
- 2 Antecedentes de la regresión lineal utilizando mínimos cuadrados ordinarios
- 3 Selección de funciones para nuestro modelo
- 4 Visualizando las relaciones
- 5 Uso de la regresión por pasos para construir un modelo robusto
- 6 Uso del módulo de regresión lineal de SciKit-Learn para predecir el clima
- 7 Recursos
- 8 Conclusión
En este repositorio de GitHub , encontrará un Jupyter Notebook con el nombre de archivo Weather Underground API.ipynb que describe las acciones paso a paso necesarias para recopilar el conjunto de datos con el que trabajaremos en este artículo y en el último. Además, en este repositorio encontrará un archivo Pandas DataFrame en escabeche llamado end-part1_df.pkl. Por lo tanto, si desea seguir adelante sin pasar por la experiencia algo dolorosa de recopilar, procesar y limpiar los datos descritos en el artículo anterior, baje el archivo pickle y use el siguiente código para deserializar los datos nuevamente en un Pandas DataFrame. para usar en esta sección.
import pickle
with open('end-part1_df.pkl', 'rb') as fp:
df = pickle.load(fp)
Si recibe un error que indica No hay módulo llamado ‘pandas.indexes’, esto se debe a que probablemente esté usando una versión de pandas más nueva que la que estaba usando en el momento de escribir este artículo (v0.18.1).
Para evitar esto, desde entonces he incluido un archivo CSV en el repositorio que contiene los datos del final de la parte 1 que puede leer usando el siguiente código en su lugar:
import pandas as pd
df = pd.read_csv('end-part2_df.csv').set_index('date')
Antecedentes de la regresión lineal utilizando mínimos cuadrados ordinarios
La regresión lineal tiene como objetivo aplicar un conjunto de suposiciones primarias con respecto a las relaciones lineales y técnicas numéricas para predecir un resultado (Y, también conocido como la variable dependiente) basado en uno o más predictores (variables independientes de X) con el objetivo final de establecer un modelo (matemático fórmula) para predecir resultados dados solo los valores de predicción con cierta cantidad de incertidumbre.
La fórmula generalizada para un modelo de regresión lineal es:
Te puede interesar:Formatear cadenas con Python
ŷ = β0 + β1 * x1 + β2 * x2 + ... + β(p-n) x(p-n) + Ε
dónde:
ŷes la variable de resultado predicha (variable dependiente)xjson las variables predictoras (variables independientes) para j = 1,2, …, p-1 parámetrosβ0es la intersección o el valor deŷcuando cada unoxjes igual a ceroβjes el cambio enŷbasado en un cambio de una unidad en uno de los correspondientesxjΕes un término de error aleatorio asociado con la diferencia entre elŷivalor predicho y elyivalor real
Ese último término en la ecuación para la regresión lineal es muy importante. La forma más básica de construir un modelo de regresión lineal se basa en un algoritmo conocido como mínimos cuadrados ordinarios que encuentra la combinación de βjvalores de ‘s que minimizan el Εtérmino.
Selección de funciones para nuestro modelo
Una suposición clave requerida por la técnica de regresión lineal es que tiene una relación lineal entre la variable dependiente y cada variable independiente. Una forma de evaluar la linealidad entre nuestra variable independiente, que por ahora será la temperatura media, y las otras variables independientes es calcular el coeficiente de correlación de Pearson .
El coeficiente de correlación de Pearson (r) es una medida de la cantidad de correlación lineal entre matrices de igual longitud que genera un valor que varía de -1 a 1. Los valores de correlación que van de 0 a 1 representan una correlación positiva cada vez más fuerte. Con esto quiero decir que dos series de datos están correlacionadas positivamente cuando los valores de una serie de datos aumentan simultáneamente con los valores de la otra serie y, a medida que ambos suben en una magnitud cada vez mayor, el valor de correlación de Pearson se acercará a 1.
Se dice que los valores de correlación de 0 a -1 están correlacionados inversa o negativamente en el sentido de que cuando los valores de una serie aumentan, los valores correspondientes en la serie opuesta disminuyen pero, a medida que los cambios de magnitud entre las series se vuelven iguales (con dirección opuesta) el valor de correlación se acercará a -1. Los valores de correlación de Pearson que se encuentran a ambos lados de cero sugieren que tienen una relación lineal débil, volviéndose más débiles a medida que el valor se acerca a cero.
Las opiniones varían entre estadísticos y libros de estadísticas sobre límites claros para los niveles de fuerza de un coeficiente de correlación. Sin embargo, he descubierto que un conjunto de clasificaciones generalmente aceptado para las fortalezas de la correlación es el siguiente:
Valor de correlación Interpretación
| 0.8 – 1.0 | Muy fuerte |
| 0.6 – 0.8 | Fuerte |
| 0.4 – 0.6 | Moderar |
| 0.2 – 0.4 | Débiles |
| 0.0 – 0.2 | Muy débil |
Para evaluar la correlación en estos datos, llamaré al corr()método del objeto Pandas DataFrame. Encadenado a esta corr()llamada de método, puedo seleccionar la columna de interés («meantempm») y volver a encadenar otra llamada de método sort_values()en el objeto de la serie Pandas resultante. Esto generará los valores de correlación de la correlación más negativa a la correlación más positiva.
df.corr()[['meantempm']].sort_values('meantempm')
meantempm
maxpressurem_1maxpressurem_2maxpressurem_3meanpressurem_1meanpressurem_2meanpressurem_3minpressurem_1minhumidity_1minhumidity_2minhumidity_3minpressurem_2minpressurem_3precipm_2precipm_1precipm_3maxhumidity_1maxhumidity_2maxhumidity_3maxdewptm_3maxtempm_3mindewptm_3meandewptm_3mintempm_3maxdewptm_2meandewptm_2mindewptm_2mintempm_2meantempm_3maxtempm_2meantempm_2maxdewptm_1meandewptm_1mindewptm_1mintempm_1maxtempm_1meantempm_1mintempmmaxtempmmeantempm
| -0.519699 |
| -0.425666 |
| -0.408902 |
| -0.365682 |
| -0.269896 |
| -0.263008 |
| -0.201003 |
| -0.148602 |
| -0.143211 |
| -0.118564 |
| -0.104455 |
| -0.102955 |
| 0.084394 |
| 0.086617 |
| 0.098684 |
| 0.132466 |
| 0.151358 |
| 0.167035 |
| 0.829230 |
| 0.832974 |
| 0.833546 |
| 0.834251 |
| 0.836340 |
| 0.839893 |
| 0.848907 |
| 0.852760 |
| 0.854320 |
| 0.855662 |
| 0.863906 |
| 0.881221 |
| 0.887235 |
| 0.896681 |
| 0.899000 |
| 0.905423 |
| 0.923787 |
| 0.937563 |
| 0.973122 |
| 0.976328 |
| 1.000000 |
Al seleccionar características para incluir en este modelo de regresión lineal, me gustaría equivocarme por el lado de ser un poco menos permisivo al incluir variables con coeficientes de correlación moderados o más bajos. Por lo tanto, eliminaré las características que tienen valores de correlación menores que el valor absoluto de 0.6. Además, dado que las variables «mintempm» y «maxtempm» son para el mismo día que la variable de predicción «meantempm», también las eliminaré (es decir, si ya conozco las temperaturas mínimas y máximas, entonces ya tengo la respuesta a mi predicción).
Con esta información, ahora puedo crear un nuevo DataFrame que solo contiene mis variables de interés.
predictors = ['meantempm_1', 'meantempm_2', 'meantempm_3',
'mintempm_1', 'mintempm_2', 'mintempm_3',
'meandewptm_1', 'meandewptm_2', 'meandewptm_3',
'maxdewptm_1', 'maxdewptm_2', 'maxdewptm_3',
'mindewptm_1', 'mindewptm_2', 'mindewptm_3',
'maxtempm_1', 'maxtempm_2', 'maxtempm_3']
df2 = df[['meantempm'] + predictors]
Visualizando las relaciones
Debido a que la mayoría de las personas, incluido yo mismo, estamos mucho más acostumbrados a mirar imágenes para evaluar y verificar patrones, graficaré cada uno de estos predictores seleccionados para demostrarme a mí mismo que, de hecho, existe una relación lineal. Para hacer esto, utilizaré el módulo pyplot de matplotlib .
Para esta gráfica, me gustaría que la variable dependiente «meantempm» sea el eje y consistente a lo largo de las 18 gráficas de variables predictoras. Una forma de lograr esto es crear una cuadrícula de gráficos. Pandas viene con una función de trazado útil llamada scatter_plot(), pero generalmente solo la uso cuando solo hay alrededor de 5 variables porque convierte el gráfico en una matriz N x N (18 x 18 en nuestro caso), lo que se vuelve difícil de ver detalles en los datos. En su lugar, crearé una estructura de cuadrícula con seis filas de tres columnas para evitar sacrificar la claridad en los gráficos.
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
# manually set the parameters of the figure to and appropriate size
plt.rcParams['figure.figsize'] = [16, 22]
# call subplots specifying the grid structure we desire and that
# the y axes should be shared
fig, axes = plt.subplots(nrows=6, ncols=3, sharey=True)
# Since it would be nice to loop through the features in to build this plot
# let us rearrange our data into a 2D array of 6 rows and 3 columns
arr = np.array(predictors).reshape(6, 3)
# use enumerate to loop over the arr 2D array of rows and columns
# and create scatter plots of each meantempm vs each feature
for row, col_arr in enumerate(arr):
for col, feature in enumerate(col_arr):
axes[row, col].scatter(df2[feature], df2['meantempm'])
if col == 0:
axes[row, col].set(xlabel=feature, ylabel="meantempm")
else:
axes[row, col].set(xlabel=feature)
plt.show()
De las gráficas anteriores se puede reconocer que todas las variables predictoras restantes muestran una buena relación lineal con la variable de respuesta («meantempm»). Además, también vale la pena señalar que todas las relaciones se ven uniformemente distribuidas al azar. Con esto quiero decir que parece haber una variación relativamente igual en la dispersión de valores desprovistos de cualquier forma de abanico o cono. Una distribución aleatoria uniforme de la dispersión a lo largo de los puntos también es otro supuesto importante de la regresión lineal utilizando el algoritmo de mínimos cuadrados ordinarios .
Uso de la regresión por pasos para construir un modelo robusto
Un modelo de regresión lineal robusto debe utilizar pruebas estadísticas para seleccionar predictores significativos y estadísticamente significativos para incluir. Para seleccionar características estadísticamente significativas, utilizaré la statsmodelsbiblioteca Python . Sin embargo, antes de pasar a la implementación práctica del uso de la statsmodelsbiblioteca, me gustaría dar un paso atrás y explicar parte del significado teórico y el propósito de este enfoque.
Un aspecto clave del uso de métodos estadísticos como la regresión lineal en un proyecto de análisis es el establecimiento y prueba de pruebas de hipótesis para validar la importancia de los supuestos hechos sobre los datos en estudio. Existen numerosas pruebas de hipótesis que se han desarrollado para probar la solidez de un modelo de regresión lineal frente a varias suposiciones que se hacen. Una de estas pruebas de hipótesis es evaluar la significancia de cada una de las variables predictoras incluidas.
La definición formal de la prueba de hipótesis para la significancia de un βjparámetro es la siguiente:
H0:βj = 0, la hipótesis nula establece que el predictor no tiene efecto sobre el valor de la variable de resultadoHa:βj ≠ 0, la hipótesis alternativa es que el predictor tiene un efecto significativo sobre el valor de la variable de resultado
Mediante el uso de pruebas de probabilidad para evaluar la probabilidad de que cada una βjsea significativa más allá del simple azar aleatorio en un umbral seleccionado Α, podemos ser más estrictos al seleccionar las variables a incluir, lo que da como resultado un modelo más robusto.
Sin embargo, en muchos conjuntos de datos puede haber interacciones que ocurren entre variables que pueden llevar a interpretaciones falsas de estas simples pruebas de hipótesis. Para probar los efectos de las interacciones sobre la significancia de cualquier variable en un modelo de regresión lineal, a menudo se aplica una técnica conocida como regresión por pasos. Con la regresión por pasos, agrega o elimina variables del modelo y evalúa la significancia estadística de cada variable en el modelo resultante.
En este artículo, utilizaré una técnica conocida como eliminación hacia atrás , donde comienzo con un modelo general completamente cargado que incluye todas mis variables de interés.
La eliminación hacia atrás funciona de la siguiente manera:
- Seleccione un nivel de significancia
Αcon el que pruebe su hipótesis para determinar si una variable debe permanecer en el modelo - Ajustar el modelo con todas las variables predictoras
- Evalúe los valores p de los
βjcoeficientes y para elΑque tenga el mayor valor p, si el valor p> avanza al paso 4, si no tiene su modelo final - Eliminar el predictor identificado en el paso 3
- Vuelva a ajustar el modelo, pero esta vez sin la variable eliminada y vuelva al paso 3.
Entonces, sin más demora, construyamos este modelo generalizado completamente cargado statsmodelssiguiendo los pasos anteriores.
# import the relevant module
import statsmodels.api as sm
# separate our my predictor variables (X) from my outcome variable y
X = df2[predictors]
y = df2['meantempm']
# Add a constant to the predictor variable set to represent the Bo intercept
X = sm.add_constant(X)
X.ix[:5, :5]
const
meantempm_1
meantempm_2
meantempm_3
mintempm_1
fecha2015-01-042015-01-052015-01-062015-01-072015-01-08
| 1.0 | -4.0 | -6.0 | -6.0 | -13.0 |
| 1.0 | -14.0 | -4.0 | -6.0 | -18.0 |
| 1.0 | -9.0 | -14.0 | -4.0 | -14.0 |
| 1.0 | -10.0 | -9.0 | -14.0 | -14.0 |
| 1.0 | -16.0 | -10.0 | -9.0 | -19.0 |
# (1) select a significance value
alpha = 0.05
# (2) Fit the model
model = sm.OLS(y, X).fit()
# (3) evaluate the coefficients' p-values
model.summary()
La summary()llamada producirá los siguientes datos en su cuaderno Jupyter:
Resultados de regresión OLS Profundidad Variable: R cuadrado: Modelo: Adj. R cuadrado: Método: Estadístico F: Fecha: Prob (estadístico F): Hora: Log-Probabilidad: No. Observaciones: AIC: Df Residuos: BIC: Df Modelo: Tipo de covarianza:
| meantempm | 0.895 |
| OLS | 0.893 |
| Mínimos cuadrados | 462.7 |
| Jue, 16 nov 2017 | 0.00 |
| 20:55:25 | -2679.2 |
| 997 | 5396. |
| 978 | 5490. |
| 18 | |
| no robusto |
coef std err t P> | t | [0.025
0.975 ] constmeantempm_1meantempm_2meantempm_3mintempm_1mintempm_2mintempm_3meandewptm_1meandewptm_2meandewptm_3maxdewptm_1maxdewptm_2maxdewptm_3mindewptm_1mintemptempmptm_1
| 1.0769 | 0.526 | 2.049 | 0.041 | 0.046 | 2.108 |
| 0.1047 | 0.287 | 0.364 | 0.716 | -0.459 | 0.669 |
| 0.3512 | 0.287 | 1.225 | 0.221 | -0.211 | 0.914 |
| -0.1084 | 0.286 | -0.379 | 0.705 | -0.669 | 0.453 |
| 0.0805 | 0.149 | 0.539 | 0.590 | -0.213 | 0.373 |
| -0.2371 | 0.149 | -1.587 | 0.113 | -0.530 | 0.056 |
| 0.1521 | 0.148 | 1.028 | 0.304 | -0.138 | 0.443 |
| -0.0418 | 0.138 | -0.304 | 0.761 | -0.312 | 0.228 |
| -0.0121 | 0.138 | -0.088 | 0.930 | -0.282 | 0.258 |
| -0.0060 | 0.137 | -0.044 | 0.965 | -0.275 | 0.263 |
| -0.1592 | 0.091 | -1.756 | 0.079 | -0.337 | 0.019 |
| -0.0113 | 0.091 | -0.125 | 0.900 | -0.189 | 0.166 |
| 0.1326 | 0.089 | 1.492 | 0.136 | -0.042 | 0.307 |
| 0.3638 | 0.084 | 4.346 | 0.000 | 0.200 | 0.528 |
| -0.0119 | 0.088 | -0.136 | 0.892 | -0.184 | 0.160 |
| -0.0239 | 0.086 | -0.279 | 0.780 | -0.192 | 0.144 |
| 0.5042 | 0.147 | 3.438 | 0.001 | 0.216 | 0.792 |
| -0.2154 | 0.147 | -1.464 | 0.143 | -0.504 | 0.073 |
| 0.0809 | 0.146 | 0.555 | 0.579 | -0.205 | 0.367 |
Todos los Durbin-Watson: sonda (todos): Jarque-Bera (JB): Sesgo: Prob (JB): Curtosis: Cond. No.
Te puede interesar:Explicación de @classmethod y @staticmethod de Python| 13.252 | 2.015 |
| 0.001 | 17.097 |
| -0.163 | 0.000194 |
| 3.552 | 291. |
Ok, reconozco que la llamada a summary() vomitó mucha información en la pantalla. ¡No se abrume! Solo nos centraremos en unos 2-3 valores en este artículo:
- P> | t | – este es el valor p que mencioné anteriormente que usaré para evaluar la prueba de hipótesis. Este es el valor que vamos a utilizar para determinar si eliminar una variable en esta técnica de eliminación hacia atrás paso a paso.
- R cuadrado: una medida que indica qué parte de la varianza general en el resultado puede explicar nuestro modelo
- Adj. R cuadrado: lo mismo que R cuadrado pero, para la regresión lineal múltiple, este valor tiene una penalización que se le aplica en función del número de variables que se incluyen para explicar el nivel de sobreajuste.
Esto no quiere decir que los demás valores de esta salida no tengan mérito, todo lo contrario. Sin embargo, tocan las idiosincrasias más esotéricas de la regresión lineal en las que simplemente no tenemos tiempo para abordar ahora. Para obtener una explicación completa de ellos, lo remitiré a un libro de texto de regresión avanzado como los Modelos de regresión lineal aplicada de Kutner , 5.a edición. así como la statsmodelsdocumentación.
# (3) cont. - Identify the predictor with the greatest p-value and assess if its > our selected alpha.
# based off the table it is clear that meandewptm_3 has the greatest p-value and that it is
# greater than our alpha of 0.05
# (4) - Use pandas drop function to remove this column from X
X = X.drop('meandewptm_3', axis=1)
# (5) Fit the model
model = sm.OLS(y, X).fit()
model.summary()
Resultados de regresión OLS Profundidad Variable: R cuadrado: Modelo: Adj. R cuadrado: Método: Estadístico F: Fecha: Prob (estadístico F): Hora: Log-Probabilidad: No. Observaciones: AIC: Df Residuos: BIC: Df Modelo: Tipo de covarianza:
| meantempm | 0.895 |
| OLS | 0.893 |
| Mínimos cuadrados | 490.4 |
| Jue, 16 nov 2017 | 0.00 |
| 20:55:41 | -2679.2 |
| 997 | 5394. |
| 979 | 5483. |
| 17 | |
| no robusto |
coef std err t P> | t | [0.025
0.975 ] constmeantempm_1meantempm_2meantempm_3mintempm_1mintempm_2mintempm_3meandewptm_1meandewptm_2maxdewptm_1maxdewptm_2maxdewptm_3mindewptm_1mindewptm_2mindewmpm_tempm_1
| 1.0771 | 0.525 | 2.051 | 0.041 | 0.046 | 2.108 |
| 0.1040 | 0.287 | 0.363 | 0.717 | -0.459 | 0.667 |
| 0.3513 | 0.286 | 1.226 | 0.220 | -0.211 | 0.913 |
| -0.1082 | 0.286 | -0.379 | 0.705 | -0.669 | 0.452 |
| 0.0809 | 0.149 | 0.543 | 0.587 | -0.211 | 0.373 |
| -0.2371 | 0.149 | -1.588 | 0.113 | -0.530 | 0.056 |
| 0.1520 | 0.148 | 1.028 | 0.304 | -0.138 | 0.442 |
| -0.0419 | 0.137 | -0.305 | 0.761 | -0.312 | 0.228 |
| -0.0121 | 0.138 | -0.088 | 0.930 | -0.282 | 0.258 |
| -0.1592 | 0.091 | -1.757 | 0.079 | -0.337 | 0.019 |
| -0.0115 | 0.090 | -0.127 | 0.899 | -0.189 | 0.166 |
| 0.1293 | 0.048 | 2.705 | 0.007 | 0.036 | 0.223 |
| 0.3638 | 0.084 | 4.349 | 0.000 | 0.200 | 0.528 |
| -0.0119 | 0.088 | -0.135 | 0.892 | -0.184 | 0.160 |
| -0.0266 | 0.058 | -0.456 | 0.648 | -0.141 | 0.088 |
| 0.5046 | 0.146 | 3.448 | 0.001 | 0.217 | 0.792 |
| -0.2154 | 0.147 | -1.465 | 0.143 | -0.504 | 0.073 |
| 0.0809 | 0.146 | 0.556 | 0.579 | -0.205 | 0.367 |
Todos los Durbin-Watson: sonda (todos): Jarque-Bera (JB): Sesgo: Prob (JB): Curtosis: Cond. No.
| 13.254 | 2.015 |
| 0.001 | 17.105 |
| -0.163 | 0.000193 |
| 3.553 | 286. |
Con respecto a su tiempo de lectura y en un intento de mantener el artículo en una extensión razonable, omitiré los ciclos de eliminación restantes necesarios para construir cada nuevo modelo, evaluar los valores p y eliminar el valor menos significativo. En su lugar, saltaré directamente al último ciclo y les proporcionaré el modelo final. Después de todo, el objetivo principal aquí era describir el proceso y el razonamiento detrás de él.
A continuación encontrará la salida del modelo final en el que convergí después de aplicar la técnica de eliminación hacia atrás. Puede ver en el resultado que todos los predictores restantes tienen valores p significativamente por debajo de nuestro Αde 0.05. Otra cosa que merece cierta atención son los valores de R cuadrado en el resultado final. Dos cosas a tener en cuenta aquí son (1) el R-cuadrado y Adj. Los valores de R-cuadrado son iguales, lo que sugiere que existe un riesgo mínimo de que nuestro modelo esté sobreajustado por variables excesivas y (2) el valor de 0.894 se interpreta de manera que nuestro modelo final explica aproximadamente el 90% de la variación observada en la variable de resultado. , el «meantempm».
model = sm.OLS(y, X).fit()
model.summary()
Resultados de regresión OLS Profundidad Variable: R cuadrado: Modelo: Adj. R cuadrado: Método: Estadístico F: Fecha: Prob (estadístico F): Hora: Log-Probabilidad: No. Observaciones: AIC: Df Residuos: BIC: Df Modelo: Tipo de covarianza:
| meantempm | 0.894 |
| OLS | 0.894 |
| Mínimos cuadrados | 1196. |
| Jue, 16 nov 2017 | 0.00 |
| 20:55:47 | -2681.7 |
| 997 | 5379. |
| 989 | 5419. |
| 7 | |
| no robusto |
coef std err t P> | t | [0.025
0.975 ] constmintempm_1mintempm_2mintempm_3maxdewptm_1maxdewptm_3mindewptm_1maxtempm_1
| 1.1534 | 0.411 | 2.804 | 0.005 | 0.346 | 1.961 |
| 0.1310 | 0.053 | 2.458 | 0.014 | 0.026 | 0.236 |
| -0.0964 | 0.037 | -2.620 | 0.009 | -0.169 | -0.024 |
| 0.0886 | 0.041 | 2.183 | 0.029 | 0.009 | 0.168 |
| -0.1939 | 0.047 | -4.117 | 0.000 | -0.286 | -0.101 |
| 0.1269 | 0.040 | 3.191 | 0.001 | 0.049 | 0.205 |
| 0.3352 | 0.051 | 6.605 | 0.000 | 0.236 | 0.435 |
| 0.5506 | 0.024 | 22.507 | 0.000 | 0.503 | 0.599 |
Todos los Durbin-Watson: sonda (todos): Jarque-Bera (JB): Sesgo: Prob (JB): Curtosis: Cond. No.
| 13.123 | 1.969 |
| 0.001 | 16.871 |
| -0.163 | 0.000217 |
| 3.548 | 134. |
Uso del módulo de regresión lineal de SciKit-Learn para predecir el clima
Ahora que hemos seguido los pasos para seleccionar predictores (características) estadísticamente significativos, podemos usar SciKit-Learn para crear un modelo de predicción y probar su capacidad para predecir la temperatura media. SciKit-Learn es una biblioteca de Machine Learning muy bien establecida que se usa ampliamente tanto en la industria como en el mundo académico. Una cosa que es muy impresionante sobre SciKit-Learn es que mantiene una API muy consistente de «ajustar», «predecir» y «probar» a través de muchas técnicas numéricas y algoritmos, lo que hace que su uso sea muy simple. Además de este diseño de API consistente, SciKit-Learn también viene con varias herramientas útiles para procesar datos comunes a muchos proyectos de Machine Learning.
Comenzaremos usando SciKit-Learn para dividir nuestro conjunto de datos en conjuntos de prueba y entrenamiento importando la train_test_split()función del sklearn.model_selectionmódulo. Dividiré los conjuntos de datos de entrenamiento y prueba en 80% de entrenamiento y 20% de prueba y asignaré un valor random_statede 12 para asegurarme de que obtendrá la misma selección aleatoria de datos que yo. Este random_stateparámetro es muy útil para la reproducibilidad de los resultados.
from sklearn.model_selection import train_test_split
# first remove the const column because unlike statsmodels, SciKit-Learn will add that in for us
X = X.drop('const', axis=1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=12)
La siguiente acción a realizar es crear el modelo de regresión utilizando el conjunto de datos de entrenamiento. Para hacer esto, importaré y usaré la LinearRegressionclase del sklearn.linear_modelmódulo. Como se mencionó anteriormente, scikit-learn puntuaciones de los principales puntos de bonificación facilidad de uso mediante la aplicación de un campo común fit()y la predict()API a través de sus numerosas técnicas numéricas que hace utilizando el usuario de la biblioteca de usar.
from sklearn.linear_model import LinearRegression
# instantiate the regressor class
regressor = LinearRegression()
# fit the build the model by fitting the regressor to the training data
regressor.fit(X_train, y_train)
# make a prediction set using the test set
prediction = regressor.predict(X_test)
# Evaluate the prediction accuracy of the model
from sklearn.metrics import mean_absolute_error, median_absolute_error
print("The Explained Variance: %.2f" % regressor.score(X_test, y_test))
print("The Mean Absolute Error: %.2f degrees celsius" % mean_absolute_error(y_test, prediction))
print("The Median Absolute Error: %.2f degrees celsius" % median_absolute_error(y_test, prediction))
The Explained Variance: 0.90
The Mean Absolute Error: 2.69 degrees celsius
The Median Absolute Error: 2.17 degrees celsius
Como puede ver en las pocas líneas de código anteriores, usar scikit-learn para construir un modelo de predicción de regresión lineal es bastante simple. Aquí es realmente donde la biblioteca brilla en su capacidad para adaptarse fácilmente a un modelo y hacer predicciones sobre un resultado de interés.
Para obtener una comprensión interpretativa de la validez de los modelos, utilicé la score()función del modelo regresor para determinar que el modelo es capaz de explicar aproximadamente el 90% de la varianza observada en la variable de resultado, temperatura media. Además, utilicé mean_absolute_error()y median_absolute_error()del sklearn.metricsmódulo para determinar que, en promedio, el valor predicho es de aproximadamente 3 grados Celsius y la mitad del tiempo está apagado en aproximadamente 2 grados Celsius.
Recursos
¿Quiere aprender las herramientas, las técnicas de Machine Learning y el análisis de datos que se utilizan en este tutorial? Aquí hay algunos recursos excelentes para comenzar:
- Análisis de datos con Pandas y Python
- Requisitos previos de aprendizaje profundo: regresión lineal en Python
- Bootcamp de Python para ciencia de datos y Machine Learning
Conclusión
En este artículo, demostré cómo usar el algoritmo de Machine Learning de regresión lineal para predecir las temperaturas climáticas medias futuras en función de los datos recopilados en el artículo anterior. Demostré cómo usar la statsmodelsbiblioteca para seleccionar predictores estadísticamente significativos basados en métodos estadísticos sólidos. Luego utilicé esta información para ajustar un modelo de predicción basado en un subconjunto de entrenamiento usando la LinearRegressionclase de Scikit-Learn . Usando este modelo ajustado, pude predecir los valores esperados basados en las entradas de un subconjunto de prueba y evaluar la precisión de la predicción, lo que indica una cantidad razonable de precisión.
Me gustaría agradecerles por leer mi artículo y espero que estén ansiosos por ver el próximo artículo final de esta serie de Machine Learning donde describo cómo construir una red neuronal para predecir la temperatura del clima.
Te puede interesar:Explicación de los entornos virtuales de Python
