Saltar al contenido

Archivos de categoría Regresión

Regresión logística en Python

Vamos a crear un modelo basado en datos de telecomunicaciones para predecir cuándo los clientes buscarán otro competidor de tal forma que podamos tomar alguna decisión para retenerlos.

¿Cuál es la diferencia entre Regresión Logística y Regresión Lineal?

Mientras la Regresión Lineal es para estimar valores continuos (ej. estimar precios de casas), no es la mejor herramienta para predecir la clase de un punto de datos observados. Para estimar la clase de punto de datos, necesitaremos una guía de lo que sería la clase más probable para ese punto de datos. Por esto, utilizamos Regresión Logística.

Regresión Lineal:

Como sabes, la Regresión lineal encuentra una función que relaciona una variable continua dependiente, y, con algunos predictores (variables independientes x_1, x_2, etc.). Por ejemplo, la regresión lineal Simple asume una función de la forma:

y = \theta_0 + \theta_1 x_1 + \theta_2 x_2 + \cdots

y encuentra los valores de los parámetros \theta_0, \theta_1, \theta_2, etc, donde el término \theta_0 es “intersección”. Generalmente se muestra como:

h_\theta(x)=\theta^T X

La Regresion Logística es una variación de una Regresión Lineal, útil cuando la variable dependiente observada, y, es categórica. Produce una fórmula que predice la probabilidad de la clase etiqueta como una función de las variables independientes.

La regresión logística es una curva especial en forma de s a partir de tomar la regresión lineal y transformar la estimación numérica en una probabilidad con la siguiente función, llamada sigmoide \sigma:

h_\theta(x)=\sigma(\theta^T X)=\frac{e^{(\theta_0 + \theta_1 x_1 + \theta_2 x_2 + \cdots)}}{1 + e^{(\theta_0 + \theta_1 x_1 + \theta_2 x_2 + \cdots)}}

O también: ProbabilidadDeUnaClase_1 = P(Y = 1 \vert X) = \sigma(\theta^T X) = \frac{e^{\theta^T X}}{1 + e^{\theta^T X}}

En esta ecuación, \theta^T X es el resultado de la regresión (la suma de las variables ponderadas por los coeficientes), e es la función exponencial y \sigma(\theta^T X) es la función sigmoide ó función logística, también llamada curva logística. Tiene una forma de “S” (curva sigmoide). En resumen, la Regresión Logística pasa la entrada a través de las funciones logística/sigmoide pero en realidad termina tratando al resultado como una probabilidad:
curva sigmoide

El objetivo del algoritmo de Regresión Logística, es encontrar los mejores parámetros \theta, para h_\theta (x) = \sigma(\theta^T X), de forma tal de que el modelo prediga lo mejor posible la clase de cada caso.

Cliente churn con Regresión Logística

Una compañía de telecomunicaciones está preocupada por el número de clientes que dejan sus líneas fijas de negocio por las de competidores de cable. Ellos necesitan entender quién se está yendo. Imagina que eres un analista en esta compañía y que tienes que descubrir quién es el cliente que se va y por qué

Primero, importemos las librerías necesarias:

import pandas as pd
import pylab as pl
import numpy as np
import scipy.optimize as opt
from sklearn import preprocessing
%matplotlib inline 
import matplotlib.pyplot as plt

Acerca del conjunto de datos

Utilizaremos datos de las telecomunicaciones para poder predecir el cliente cancelador (churn). Estos son datos históricos de clientes donde cada fila representa un cliente. Los datos son fáciles de comprender, y podrás descubrir conclusiones que puedes usar de inmediato. Generalmente, es menos caro mantener clientes que conseguir nuevos, así que el foco de este análisis es predecir los clientes que se quedarían en la compañía.
Estos datos proveen información que ayudarán a predecir comportamientos que retendrán a los clientes. Puedes analizar toda la información relevante del cliente y desarrollar programas de retención centrados en los clientes.

Los datos incluyen información acerca de:

  • Clientes que se fueron el último mes – la columna se llama Churn
  • Los servicios que cada cliente ha contratado – teléfono, líneas múltiples, internet, seguridad online, resguardo online, protección de dispositivos, soporte técnico y streaming de TV y películas
  • Información de la cuenta del cliente – cuánto hace que es cliente, contrato, método de pago, facturación digital, cargos mensuales y cargos totales
  • Información demográfica de los clientes – sexo, rango de edad y si tienen pareja y dependientes

Cargar los datos “Cancelaciones” de la Telco

“Telco Churn” es un archivo de datos ficticio que trata sobre los esfuerzos de una compañía de telecomunicaciones para reducir la huída de sus clientes. Cada caso corresponde a un cliente y se guarda información demográfica e información referente al uso del servicio. Antes de trabajar con los datos, debes utilizar la URL para obtener el archivo ChurnData.csv. Para descargarlo, utilizaremos !wget desde IBM Object Storage.

!wget -O ChurnData.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/ChurnData.csv
--2020-02-12 16:42:15--  https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/ChurnData.csv
Resolving s3-api.us-geo.objectstorage.softlayer.net (s3-api.us-geo.objectstorage.softlayer.net)... 67.228.254.196
Connecting to s3-api.us-geo.objectstorage.softlayer.net (s3-api.us-geo.objectstorage.softlayer.net)|67.228.254.196|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 36144 (35K)

Saving to: ‘ChurnData.csv’

ChurnData.csv 100%[===================>] 35.30K –.-KB/s in 0.02s

2020-02-12 16:42:15 (1.56 MB/s) – ‘ChurnData.csv’ saved [36144/36144]

Cargar los Datos desde el Archivo CSV

churn_df = pd.read_csv("ChurnData.csv")
churn_df.head()
tenure age address income ed employ equip callcard wireless longmon pager internet callwait confer ebill loglong logtoll lninc custcat churn
0 11.0 33.0 7.0 136.0 5.0 5.0 0.0 1.0 1.0 4.40 1.0 0.0 1.0 1.0 0.0 1.482 3.033 4.913 4.0 1.0
1 33.0 33.0 12.0 33.0 2.0 0.0 0.0 0.0 0.0 9.45 0.0 0.0 0.0 0.0 0.0 2.246 3.240 3.497 1.0 1.0
2 23.0 30.0 9.0 30.0 1.0 2.0 0.0 0.0 0.0 6.30 0.0 0.0 0.0 1.0 0.0 1.841 3.240 3.401 3.0 0.0
3 38.0 35.0 5.0 76.0 2.0 10.0 1.0 1.0 1.0 6.05 1.0 1.0 1.0 1.0 1.0 1.800 3.807 4.331 4.0 0.0
4 7.0 35.0 14.0 80.0 2.0 15.0 0.0 1.0 0.0 7.10 0.0 0.0 1.0 1.0 0.0 1.960 3.091 4.382 3.0 0.0

Selección y pre-procesamiento de datos

Seleccionemos algunas características para el modelado. También cambiemos el tipo de dato del objetivo (target) para que sea un número entero (integer), ya que es un requerimiento del algoritmo skitlearn:

churn_df = churn_df[['tenure', 'age', 'address', 'income', 'ed', 'employ', 'equip',   'callcard', 'wireless','churn']]
churn_df['churn'] = churn_df['churn'].astype('int')
churn_df.head()
tenure age address income ed employ equip callcard wireless churn
0 11.0 33.0 7.0 136.0 5.0 5.0 0.0 1.0 1.0 1
1 33.0 33.0 12.0 33.0 2.0 0.0 0.0 0.0 0.0 1
2 23.0 30.0 9.0 30.0 1.0 2.0 0.0 0.0 0.0 0
3 38.0 35.0 5.0 76.0 2.0 10.0 1.0 1.0 1.0 0
4 7.0 35.0 14.0 80.0 2.0 15.0 0.0 1.0 0.0 0
churn_df.describe()
tenure age address income ed employ equip callcard wireless churn
count 200.000000 200.000000 200.000000 200.000000 200.00000 200.00000 200.000000 200.000000 200.000000 200.000000
mean 35.505000 41.165000 11.650000 75.130000 2.82500 10.22500 0.425000 0.705000 0.290000 0.290000
std 21.640971 13.076803 10.158419 128.430468 1.28555 8.95743 0.495584 0.457187 0.454901 0.454901
min 1.000000 19.000000 0.000000 9.000000 1.00000 0.00000 0.000000 0.000000 0.000000 0.000000
25% 16.750000 31.000000 3.000000 31.000000 2.00000 3.00000 0.000000 0.000000 0.000000 0.000000
50% 33.500000 40.000000 9.000000 48.000000 3.00000 7.50000 0.000000 1.000000 0.000000 0.000000
75% 55.250000 51.000000 18.000000 80.000000 4.00000 17.00000 1.000000 1.000000 1.000000 1.000000
max 72.000000 76.000000 48.000000 1668.000000 5.00000 44.00000 1.000000 1.000000 1.000000 1.000000

Definamos X, e y para nuestro set de datos:

X = np.asarray(churn_df[['tenure', 'age', 'address', 'income', 'ed', 'employ', 'equip']])
X[0:5]
array([[ 11.,  33.,   7., 136.,   5.,   5.,   0.],
       [ 33.,  33.,  12.,  33.,   2.,   0.,   0.],
       [ 23.,  30.,   9.,  30.,   1.,   2.,   0.],
       [ 38.,  35.,   5.,  76.,   2.,  10.,   1.],
       [  7.,  35.,  14.,  80.,   2.,  15.,   0.]])
y = np.asarray(churn_df['churn'])
y [0:5]
array([1, 1, 0, 0, 0])

También, normalicemos el set de datos:

from sklearn import preprocessing
X = preprocessing.StandardScaler().fit(X).transform(X)
X[0:5]
array([[-1.13518441, -0.62595491, -0.4588971 ,  0.4751423 ,  1.6961288 ,
        -0.58477841, -0.85972695],
       [-0.11604313, -0.62595491,  0.03454064, -0.32886061, -0.6433592 ,
        -1.14437497, -0.85972695],
       [-0.57928917, -0.85594447, -0.261522  , -0.35227817, -1.42318853,
        -0.92053635, -0.85972695],
       [ 0.11557989, -0.47262854, -0.65627219,  0.00679109, -0.6433592 ,
        -0.02518185,  1.16316   ],
       [-1.32048283, -0.47262854,  0.23191574,  0.03801451, -0.6433592 ,
         0.53441472, -0.85972695]])

Entrenar/Probar el set de datos

Ahora, dividamos nuestro set de datos en dos sets, entrenamiento y prueba:

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=4)
print ('Train set:', X_train.shape,  y_train.shape)
print ('Test set:', X_test.shape,  y_test.shape)
Train set: (160, 7) (160,)
Test set: (40, 7) (40,)

Modelando (Regresión Logística con Scikit-learn)

Construyamos nuestro modelo utilizando LogisticRegression con el package Scikit-learn. Esta función implementa regresión logística y puede usar distintos optimizadores numéricos para encontrar parámetros, a saber, ‘newton-cg’, ‘lbfgs’, ‘liblinear’, ‘sag’, ‘saga’ solvers. Puedes también encontrar más información sobre los pros y contras de estos optimizadores si buscas en internet.

La versión de Regresión Logística soporta regularización. Esto es, una técnica que soluciona problemas de sobreajuste en modelos de machine learning. El parámetro C indica fuerza de regularización inversa la cual debe ser un número flotante positivo. Valores más pequeños indican regularización más fuerte. Llenemos nuesto modelo con el subconjunto de entrenamiento:

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix
LR = LogisticRegression(C=0.01, solver='liblinear').fit(X_train,y_train)
LR
LogisticRegression(C=0.01, class_weight=None, dual=False, fit_intercept=True,
          intercept_scaling=1, max_iter=100, multi_class='warn',
          n_jobs=None, penalty='l2', random_state=None, solver='liblinear',
          tol=0.0001, verbose=0, warm_start=False)

Ahora, podremos predecir usando nuestro set de prueba:

yhat = LR.predict(X_test)
yhat
array([0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0])

predict_proba devuelve estimaciones para todas las clases. La primer columna es la probabilidad de la clase 1, P(Y=1|X), y la segunda columna es la probabilidad de la clase 0, P(Y=0|X):

yhat_prob = LR.predict_proba(X_test)
yhat_prob
array([[0.54132919, 0.45867081],
       [0.60593357, 0.39406643],
       [0.56277713, 0.43722287],
       [0.63432489, 0.36567511],
       [0.56431839, 0.43568161],
       [0.55386646, 0.44613354],
       [0.52237207, 0.47762793],
       [0.60514349, 0.39485651],
       [0.41069572, 0.58930428],
       [0.6333873 , 0.3666127 ],
       [0.58068791, 0.41931209],
       [0.62768628, 0.37231372],
       [0.47559883, 0.52440117],
       [0.4267593 , 0.5732407 ],
       [0.66172417, 0.33827583],
       [0.55092315, 0.44907685],
       [0.51749946, 0.48250054],
       [0.485743  , 0.514257  ],
       [0.49011451, 0.50988549],
       [0.52423349, 0.47576651],
       [0.61619519, 0.38380481],
       [0.52696302, 0.47303698],
       [0.63957168, 0.36042832],
       [0.52205164, 0.47794836],
       [0.50572852, 0.49427148],
       [0.70706202, 0.29293798],
       [0.55266286, 0.44733714],
       [0.52271594, 0.47728406],
       [0.51638863, 0.48361137],
       [0.71331391, 0.28668609],
       [0.67862111, 0.32137889],
       [0.50896403, 0.49103597],
       [0.42348082, 0.57651918],
       [0.71495838, 0.28504162],
       [0.59711064, 0.40288936],
       [0.63808839, 0.36191161],
       [0.39957895, 0.60042105],
       [0.52127638, 0.47872362],
       [0.65975464, 0.34024536],
       [0.5114172 , 0.4885828 ]])

Evaluación

Índice jaccard

Probemos con el índice jaccard para la evaluación de precisión. Podemos definir como jaccard al tamaño de la intersección dividida por el tamaño de la unión de dos set de etiquetas. Si todo el set de etiquetas de muestra predichas coinciden con el set real de etiquetas, entonces la precisión es 1.0; sino, sería 0.0.

from sklearn.metrics import jaccard_similarity_score
jaccard_similarity_score(y_test, yhat)
0.75

Matriz de confusión

Otra forma de mirar la precisión del clasificador es ver la matriz de confusión.

from sklearn.metrics import classification_report, confusion_matrix
import itertools
def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues):
  """
  Esta función muestra y dibuja la matriz de confusión.
  La normalización se puede aplicar estableciendo el valor `normalize=True`.
  """
  if normalize:
    cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
    print("Matriz de confusión normalizada")
  else:
    print('Matriz de confusión sin normalización')

  print(cm)

  plt.imshow(cm, interpolation='nearest', cmap=cmap)
  plt.title(title)
  plt.colorbar()
  tick_marks = np.arange(len(classes))
  plt.xticks(tick_marks, classes, rotation=45)
  plt.yticks(tick_marks, classes)

  fmt = '.2f' if normalize else 'd'
  thresh = cm.max() / 2.
  for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
    plt.text(j, i, format(cm[i, j], fmt), horizontalalignment="center", color="white" if cm[i, j] > thresh else "black")

​  plt.tight_layout()
  plt.ylabel('Etiqueta Real')
  plt.xlabel('Etiqueta Predicha')
print(confusion_matrix(y_test, yhat, labels=[1,0]))
[[ 6  9]
 [ 1 24]]
# Calcular la matriz de confusión
cnf_matrix = confusion_matrix(y_test, yhat, labels=[1,0])
np.set_printoptions(precision=2)

​# Dibujar la matriz de confusión no normalizada
plt.figure()
plot_confusion_matrix(cnf_matrix, classes=['churn=1','churn=0'],normalize= False, title='Matriz de confusión')
Matriz de confusión sin normalización
[[ 6  9]
 [ 1 24]]

Observa la primer fila. Ahí están los clientes cuyo valor churn en el set de prueba es 1. Como podrás calcular, de 40 clientes, el valor churn de 15 de ellos es 1. Y de otros 15, el clasificador predijo que 6 de ellos son 1 y 9 0.
Quiere decir que, para 6 clientes, el valor actual de churn fue 1 en el set de pruebas y el clasificador los predijo correctamente como 1. Sin embargo, mientras la etiqueta actual de 9 clientes era 1, el clasificador los predijo como 0, lo cual no es muy bueno. Lo podemos considerar como un error del modelo para la primer fila.
¿Qué pasa con los clientes con valor churn 0? Miremos la segunda fila. Parece que hay 25 clientes con valor churn 0.
El clasificador predijo correctamente 24 de ellos como 0 y uno de ellos equivocadamente como 1. Así que ha hecho un buen trabajo prediciendo los clientes con churn 0. Una ventaja de la matriz de confusión es que muestra la abilidad del modelo para correctamente predecir o separar las clases. En el caso de clasificador binario, como el ejemplo, podemos entender a estos números como la cantidad de positivos verdaderos, negativos verdaderos y negativos falsos.

print (classification_report(y_test, yhat))
              precision    recall  f1-score   support

           0       0.73      0.96      0.83        25
           1       0.86      0.40      0.55        15

   micro avg       0.75      0.75      0.75        40
   macro avg       0.79      0.68      0.69        40
weighted avg       0.78      0.75      0.72        40


Partiendo de la cantidad de cada sección podemos calcular la precisión y el grado(recall) de cada etiqueta:

  • Precision es una medida de certeza basada en una etiqueta predicha. Se define de esta forma: precision = TP / (TP + FP)
  • Recall es un grado positivo verdadero. Se define de esta forma: Recall = TP / (TP + FN)

Por lo tanto, podemos calcular la precisión y grado de cada clase.

F1 score: Ahora estamos en condiciones de calcular los puntajes F1 para cada etiqueta basada en la precisión y grado de cada etiqueta.

El puntaje F1 es el promedio armónico de la precisión y grado, donde un grado F1 alcanza su mejor valor en 1 (precisión y grado perfectos) y peor escenario en 0. Es una buena forma de mostrar que un clasificador tiene un buen valor tanto para la precisión como para el grado.

Y finalmente, podemos decir que la exactitud promedio para este clasificador es el promedio del score f1 para ambas etiquetas, cuyo valor es is 0.72 en nuestro caso.

log loss

Ahora, probemos log loss para la evaluación. En regresión logística, la salida puede ser que la probabilidad de cliente churn sea sí (o su equivalente 1). Esta probabilidad es un valor entre 0 y 1. Log loss( pérdida logarítmica) mida el rendimiento de un clasificador donde la salida predicha es una probabilidad de valor entre 0 y 1.

from sklearn.metrics import log_loss
log_loss(y_test, yhat_prob)
0.6017092478101185

Modelo con valores diferentes

Vamos a construir el modelo de Regresión Logística de nuevo para el mismo set de datos, pero esta vez, utilizando valores diferentes de solucionador y regularización.

LR2 = LogisticRegression(C=0.01, solver='sag').fit(X_train,y_train)
yhat_prob2 = LR2.predict_proba(X_test)
print ("LogLoss: : %.2f" % log_loss(y_test, yhat_prob2))
LogLoss: : 0.61
0 Seguir leyendo →

Regresión no lineal en Pyton

Importación de los paquetes básicos

import numpy as np              # paquete básico para calculos científicos
import matplotlib.pyplot as plt # para crear graficos
%matplotlib inline              # muestra los graficos en la linea de comandos de Python

Creación de diferentes conjuntos de datos

Función cúbica (y = a x^{3} + b x^{2} + c x + d)

x = np.arange(-5.0, 5.0, 0.1)
##Puede ajustar la pendiente y la intersección para verificar los cambios del gráfico
y = 1*(x**3) + 1*(x**2) + 1*x + 3
y_noise = 20 * np.random.normal(size=x.size)
ydata = y + y_noise
plt.plot(x, ydata,  'bo')
plt.plot(x,y, 'r') 
plt.ylabel('Variable dependiente')
plt.xlabel('Variable indepdendiente')
plt.show()

Función cuadrática (y = x^{2})

x = np.arange(-5.0, 5.0, 0.1)
##Se puede ajustar la pendiente y la intersección para verificar los cambios en el gráfico
y = np.power(x,2)
y_noise = 2 * np.random.normal(size=x.size)
ydata = y + y_noise
plt.plot(x, ydata,  'bo')
plt.plot(x,y, 'r') 
plt.ylabel('Variable dependiente')
plt.xlabel('Variable indepdiendente')
plt.show()

Exponencial (y = a + b c^{x})

X = np.arange(-5.0, 5.0, 0.1)
##Se puede ajustar la pendiente y la intersección para verificar los cambios en el gráfico
Y= np.exp(X)
plt.plot(X,Y) 
plt.ylabel('Variable Dependiente')
plt.xlabel('Variable Independiente')
plt.show()

Logarítmica (y = \log(x))

X = np.arange(-5.0, 5.0, 0.1)
Y = np.log(X)
plt.plot(X,Y) 
plt.ylabel('Variable Dependiente')
plt.xlabel('Variable Independiente')
plt.show()

Sigmoidal/Logística (y = a + \dfrac{b}{1 + c^{(x - d)}})

X = np.arange(-5.0, 5.0, 0.1)
Y = 1-4/(1+np.power(3, X-2))
plt.plot(X,Y) 
plt.ylabel('Variable Dependiente')
plt.xlabel('Variable Independiente')
plt.show()

Ejemplo completo

Descarga del fichero de datos

import numpy as np
import pandas as pd
#downloading dataset
!wget -nv -O china_gdp.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/china_gdp.csv
df = pd.read_csv("china_gdp.csv")
df.head(10)  # mostramos los primeros datos 
Year Value
0 1960 5.918412e+10
1 1961 4.955705e+10
2 1962 4.668518e+10
3 1963 5.009730e+10
4 1964 5.906225e+10
5 1965 6.970915e+10
6 1966 7.587943e+10
7 1967 7.205703e+10
8 1968 6.999350e+10
9 1969 7.871882e+10

Mostrado de los datos

plt.figure(figsize=(8,5))
x_data, y_data = (df["Year"].values, df["Value"].values)
plt.plot(x_data, y_data, 'ro')
plt.ylabel('GDP')
plt.xlabel('Year')
plt.show()

Eligiendo un modelo

A primera vista, determinamos que la función lógica podría ser una buena primera aproximación, ya que tiene la propiedad de comenzar con un crecimiento leve, aumentando en el medio y luego descendiendo nuevamente hacia el final; como vimos anteriormente y simplificando, la formula es y = \dfrac{1}{1 + e^{\beta_1(x - \beta_2)}} donde \beta_1 controla lo llano de la curva y \beta_2 lleva la curva sobre el eje x.

#define el modelo
def sigmoid(x, Beta_1, Beta_2):
     y = 1 / (1 + np.exp(-Beta_1*(x-Beta_2)))
     return y

#ejecutamos un primer modelo
beta_1 = 0.10
beta_2 = 1990.0

#función logística
Y_pred = sigmoid(x_data, beta_1 , beta_2)

#predicción de puntos
plt.plot(x_data, Y_pred*15000000000000.)
plt.plot(x_data, y_data, 'ro')


Nuestra tarea aquí es encontrar los mejores parámetros para nuestro modelo. Normalicemos primero nuestro x e y:

xdata =x_data/max(x_data)
ydata =y_data/max(y_data)

Para buscar los mejores parámetros podemos utilizar curve_fit la cual utiliza cuadrados mínimos no lineales para cuadrar con la función sigmoide. popt son nuestros parámetros optimizados.

from scipy.optimize import curve_fit
popt, pcov = curve_fit(sigmoid, xdata, ydata)
#imprimir los parámetros finales
print(" beta_1 = %f, beta_2 = %f" % (popt[0], popt[1]))

beta_1 = 690.447530, beta_2 = 0.997207

Dibujamos el modelo

x = np.linspace(1960, 2015, 55)
x = x/max(x)
plt.figure(figsize=(8,5))
y = sigmoid(x, *popt)
plt.plot(xdata, ydata, 'ro', label='data')
plt.plot(x,y, linewidth=3.0, label='fit')
plt.legend(loc='best')
plt.ylabel('GDP')
plt.xlabel('Year')
plt.show()

Vemos la exactitud de nuestro modelo

# divide los datos en entrenamiento y prueba
msk = np.random.rand(len(df)) < 0.8
train_x = xdata[msk]
test_x = xdata[~msk]
train_y = ydata[msk]
test_y = ydata[~msk]

# construye el modelo utilizando el set de entrenamiento
popt, pcov = curve_fit(sigmoid, train_x, train_y)

# predecir utilizando el set de prueba
y_hat = sigmoid(test_x, *popt)

# evaluation
print("Promedio de error absoluto: %.2f" % np.mean(np.absolute(y_hat - test_y)))
print("Suma residual de cuadrados (MSE): %.2f" % np.mean((y_hat - test_y) ** 2))
from sklearn.metrics import r2_score
print("R2-score: %.2f" % r2_score(y_hat , test_y) )

Promedio de error absoluto: 0.04
Suma residual de cuadrados (MSE): 0.00
R2-score: 0.97

0 Seguir leyendo →

Regresión no lineal

Regresión no lineal.

El gráfico mostrado corresponde al producto bruto interno (PBI) por año para un país. ¿Se puede predecir el PIB en función del tiempo? ¿Podemos usar una regresión lineal simple para modelarlo?Regresion no lineal
Si los datos muestran una tendencia curvada, entonces la regresión lineal no producirá un resultado muy preciso, simplemente porque la regresión lineal presume que los datos son lineales. Se parece a una función logística o exponencial. Por lo tanto, se necesita un método especial de cálculo cuando la regresión es no lineal.

Si asumimos que el modelo para este conjunto de datos son funciones exponenciales, como por ejemplo, y = \theta_0 + \theta_1 {\theta_2}^{x}, nuestro trabajo consiste en estimar los parámetros del modelo, es decir, \theta, y utilizar el modelo ajustado para predecir valores de la variable dependiente para casos desconocidos o futuros. De hecho, existen muchas regresiones diferentes que se pueden utilizar para adaptarse a cualquier aspecto del conjunto de datos.

graficas no linealesEn estos gráficos se pueden ver líneas de regresión cuadrática y cúbica, y se puede continuar hasta el grados infinitos. En esencia, podemos llamar a todos estos casos “regresión polinómica”, donde la relación entre la variable independiente x y la variable dependiente y se modelan como un polinomio grado n en x. Con muchos los tipos de regresión para elegir, hay una buena probabilidad de que uno se ajuste bien a su conjunto de datos. Es importante elegir una regresión que se adapte mejor a los datos.

Método de cálculo

La regresión polinómica se ajusta a una línea curvada de sus datos. Un ejemplo simple de polinomial, con el grado 3, se muestra como y = \theta_0 + \theta_1 x + {\theta_2 x}^{2} + {\theta_3 x}^{3} donde \theta son parámetros a estimar que hacen que el modelo se ajuste perfectamente a los datos. A pesar de que la relación entre x y y es no lineal, y la regresión polinómica puede ajustarse a ellas, un modelo de regresión polinomial puede ser expresado como regresión lineal realizando cambios en las variables: Dada la ecuación polinómica de tercer grado, si definimos que x_1 = x y x_2 = x^{2} y x_3 = x^{3}, el modelo se convierte en una regresión lineal simple con nuevas variables y = \theta_0 + \theta_1 x_1 + \theta_2 x_2 + \theta_3 x_3.

Esta regresión polinómica se considera un caso especial de regresión lineal múltiple tradicional. Por lo tanto, puede utilizar el mismo mecanismo que la regresión lineal para resolver el problema y utilizar el modelo de mínimos cuadrados. Los mínimos cuadrados es un método para estimar los parámetros desconocidos en una modelo de regresión lineal, minimizando la suma de los cuadrados de las diferencias entre la variable dependiente observada en el conjunto de datos y las predicciones de la función lineal.

Características

Para decir que una regresión es no lineal, debe cumplir que:

  1. Existe una relación no lineal entre la variable dependiente y el conjunto de variables independientes.
  2. Su modelo debe ser una función no lineal de los parámetros \theta, no necesariamente las características x.ecuaciones no lineales

Cuando se trata de la ecuación no lineal, puede ser de forma de exponencial, logarítmica, logística, o muchos otros tipos. En todas estas ecuaciones, el cambio de y depende de los cambios en los parámetros \theta, no necesariamente en x solamente. En contraste con la regresión lineal, no podemos utilizar el método de “mínimos cuadrados” ordinarios para ajustar los datos.

¿Cómo se puede saber si un problema es lineal o no lineal de una manera fácil? Podemos averiguar visualmente si la relación es lineal o no lineal trazando gráficos bivariados de las variables de salida con cada variable de entrada. Además, se puede calcular el coeficiente de correlación entre variables independientes y dependientes, y si para todas las variables es 0.7 o superior hay una tendencia lineal, y, por lo tanto, no es apropiado ajustar una regresión no lineal. También podemos usar una regresión no lineal cuando no podemos modelar con precisión la relación con los parámetros lineales.
¿Cómo debo modelar mis datos, si se muestran no lineales en un diagrama de dispersión? para hacer frente a esto se tiene que usar una regresión polinómica y un modelo de regresión
no lineal, “transformando” sus datos.(VER EJEMPLO EN PYTHON)

Ir al artículo anterior de la serie: Evaluación del modelo de regresión

Ir al artículo siguiente de la serie: Introducción a la clasificación

0 Seguir leyendo →

Evaluación del modelo de regresión

Evaluación del modelo de regresión

El objetivo al realizar un modelo de regresión es predecir con precisión un caso desconocido. Con este fin, tenemos que realizar una evaluación del modelo de regresión después de crear el modelo. Para realizarlo podemos usar el entrenamiento y la prueba en el mismo conjunto de datos. También podemos realizar una división del conjunto de datos para entrenamiento y otro para prueba.

La primera solución consiste en seleccionar una parte de nuestro conjunto de datos para la realización de pruebas. Usamos todo el conjunto de datos para el entrenamiento, y construimos un modelo usando este conjunto de entrenamiento. Luego seleccionamos una pequeña porción del conjunto de datos, que se utiliza como valores reales del conjunto de pruebas. Pasamos este conjunto por nuestro modelo construido, pronosticando valores. Por último, comparamos los valores pronosticados por nuestro modelo con los valores reales.

Modelo Train/Test Split

Una forma de mejorar la precisión fuera de la muestra consiste en utilizar otro enfoque de evaluación denominado “Train/Test Split” (División entre entrenamiento y prueba). En este enfoque, seleccionamos una parte de nuestro conjunto de datos para entrenamiento y el resto se utiliza para probar. El modelo se basa en el conjunto de formación y luego se pasa para la predicción. Finalmente, los valores pronosticados para el conjunto de pruebas se comparan con los valores reales del conjunto de datos. Este modelo implica la división del conjunto de datos en conjuntos de formación y pruebas, respectivamente, que son mutuamente excluyentes. Esto proporcionará una evaluación más precisa sobre la precisión de fuera de la muestra, ya que la prueba del conjunto de datos NO forma parte del conjunto de datos que se ha utilizado para formar los datos.

Este modelo depende de los conjunto de datos en los que los datos fueron formados y probados. Así que aún tiene algunos problemas debido a esta dependencia. Otro modelo de evaluación, denominado “k-fold cross-validation”, soluciona la mayoría de estos problemas. Este modelo se basa en hacer k-veces el modelo “Train/Test Split” y luego promediando la precisión. Supongamos que hemos tomado la decisión de realizar 4 pruebas de tipo “Train/Test Split”, para cada una de ellas tomaremos 1/4 de todo el conjunto de datos como datos para las pruebas, y el resto para la formación del modelo. Se evalua la precisión para cada uno de los modelos y finalmente se calcula el promedio de precisón.

Evaluación del modelo

Hay diferentes métricas de la evaluación del modelo de regresión, pero la mayoría de ellos se basan en la similitud de los valores pronosticados y reales. Una de las métricas más simples para calcular la precisión de nuestro modelo
de regresión es el error calculado como la diferencia promedio entre los valores predichos y los reales para todas las filas.

En un sentido general, cuando se prueba con un conjunto de datos en el que se conoce el valor objetivo para cada dato puntual, es capaz de obtener un porcentaje de predicciones exactas para el modelo. Este enfoque de evaluación probablemte tendría una alta “precisión de formación” y una baja “precisión fuera de la muestra”, ya que el modelo conoce todos los datos de prueba.
La precisión de la formación es el porcentaje de predicciones correctas que hace el modelo cuando se utiliza el conjunto de datos de prueba. Sin embargo, una alta precisión en la formación no es necesariamente algo bueno, ya que puede dar como resultado un sobreajuste de los datos, un modelo que puede estar mostrando ruido y producir un modelo no generalizado.
La precisión fuera de la muestra es el porcentaje de las predicciones correctas que el modelo realiza sobre datos que NO ha sido formado el modelo. Si hacemos “formación y prueba” en el mismo conjunto de datos probablemente el modelo tendrá una precisión baja fuera de la muestra.

Es importante que nuestros modelos tengan una precisión alta, fuera de la muestra, ya que deben hacer predicciones correctas sobre datos desconocidos.

Metricas de evaluación

Antes de poder definir las diferentes métricas utilizadas para evaluar la regresión, tenemos que definir lo que realmente es un error: el error de un modelo de regresión es la diferencia entre los datos puntuales y la línea de tendencia generada por el algoritmo.
Un error puede ser determinado de multiples maneras:

Formulas de eveluación

  • Error medio absoluto (MAE) es la media del valor absoluto de los errores. Es la medida más fácil de entender, ya que es sólo el error promedio.
  • Error cuadrático medio (MSE) es la media de los errores al cuadrado. Es más popular que el error medio absoluto porque el enfoque se orienta más hacia grandes errores. Esto se debe a que el término al cuadrado aumenta exponencialmente los errores más grandes en comparación con los más pequeños.
  • Raiz cuadrada del error cuadrático medio (RMSE) es la raíz cuadrada de la anterior medida. Esta es una de las métricas más populares de las métricas de evaluación porque es interpretable en las mismas unidades que el vector de respuesta (o unidades y) haciendo fácil de correlacionar con la información.
  • Error absoluto relativo (RAE), también conocido como la suma residual de cuadrado, donde la barra de y es un valor medio de y, toma el error absoluto total y la normaliza dividiendo por el error absoluto total del predictor simple.
  • Error cuadrático relativo (RSE) es muy similar a “Error absoluto relativo”, pero se usa para calcular R-cuadrado. R-cuadrado no es un error, si no, una métrica popular para la precisión de su modelo. Representa como de cerca están los valores de los datos de la línea de regresión ajustada. Cuanto más alto sea el R-cuadrado, mejor encaja el modelo a los datos.

 

Cada una de estas métricas se puede utilizar para cuantificar la predicción. La elección de la métrica depende del tipo de modelo, el tipo de datos y el dominio del conocimiento.

Ir al artículo anterior de la serie: Regresión lineal múltiple

Ir al artículo siguiente de la serie: Regresión no lineal

0 Seguir leyendo →

Regresión lineal múltiple en R

Regresión múltiple

require(MASS) # importa la libreria MASS con funciones y métodos estadísticos
require(ISLR) # importa la librería ISLR con datos para un aprender estadística con R
data("Boston") # utiliza el conjunto de datos Boston del paquete MASS. Mediana del valor de la vivienda

# Estudio simple de los datos
require(psych) # importa la librería psych con procedimientos para la investigación psicológica.
summary(Boston) # muestra estadísticos básicos del conjunto de datos
multi.hist(x = Boston[,1:3], dcol = c("blue","red"), dlty = c("dotted", "solid"), main = "") # crea un histograma básico

# Creacion de un modelo múltiple de regresion para predecir el valor de la vivienda (medv) en función del resto de datos
modelo_multiple <- lm(formula = medv ~ ., data = Boston)
# También se pueden especificar una a una 
summary(modelo_multiple) # para visualizar los principales parámetros del modelo generado

Datos a observar:

  • p-value del estadístico F. Si es bajo (<0.05) significa que hay al menos un predictor que tiene relación con la respuesta.
  • RSE (Residual standard error): Son las unidades que se aleja, en promedio, cualquier predicción del modelo. Hay que tener en cuenta el promedio de la variable respuesta, por lo que el RSE se suele medir en porcentaje: \frac{RSE}{promedio variable respuesta}=X\%
  • R^2: Indica el tanto por uno (multiplicar por 100 para saber el %) de la variabilidad explicada por el modelo. La ventaja de R^2 es que es independiente de la escala en la que se mida la variable respuesta, por lo que su interpretación es más sencilla.
  • Intercept(\beta_0): El valor promedio de la variable respuesta cuando todos los predictores son 0. Es la ordenada en el origen en un entorno n-dimensional
  • Predictores(\beta_i): Por cada unidad que se incrementa cada predictor, indica cuanto vale la variable respuesta. Es la pendiente en un entorno n-dimensional. En esta tabla se muestra también los p-values, por lo que puede verse para cada variable si influye o no en el model: p-values muy cercanos a 1 significa que la variable no influye en el modelo y deberian excluirse. Esta exclusión basada en los p-value no es recomendable, en su lugar se recomienda emplear métodos de best subset selection, stepwise selection (forward, backward e hybrid) o Shrinkage/regularization.

Para usar el método de Stepwise existe la funcion “step”: step(object, scope, scale = 0, direction = c(“both”, “backward”, “forward”), trace = 1, keep = NULL, steps = 1000, k = 2, …)

step(modelo_multiple, direction = "both", trace = 0)

La función nos muestra los valores Intercept y de los multiplicadores de cada variable para aquellas que tienen influencia en el odelo, descartando otras que tienen menor influencia. Una vez descartadas algunas de las variables, se ejecuta de nuevo el modelo para ver sus estadísticos:

modelo_multiple <- lm(formula = medv ~ crim + zn + chas +  nox + rm +  dis + rad + tax + ptratio + black + lstat, data = Boston)
# También se pueden indicar todas las variables de un data.frame y exluir algunas
# modelo_multiple <- lm(formula = medv~. -age -indus, data = Boston)
summary(modelo_multiple)

Estudio de los residuos del modelo.

Para confirmar que un modelo de regresión lineal múltiple por mínimos cuadrados cumple su labor, lo mejor es estudiar los residuos del modelo. En R, los residuos se almacenan dentro del modelo, bajo el nombre de “residuals”, además, R puede generar los gráficos más usados para la evaluar los residuos del modelo:

par(mfrow = c(1,2)) # Indicamos que queremos 2 gráficos por pantalla (1 fila y 2 columnas)
plot(modelo_multiple) # Pintamos los graficos de residuos

Aparecen 4 gráficos:

  1. El primer gráfico muestra los residuos para cada predicción. Si hay una distribución lineal de los residuos, entonces podemos pensar que el modelo se ajusta bien. Si se observa cualquier tipo de distribución no lineal ni constante, podemos sospechar que el modelo no se ajusta del todo.
  2. El segundo gráfico es de tipo Normal Q-Q. Compara los residuos estandarizados con la distribución teorica Normal. Si los puntos se alejan de la linea normal, indica que los residuos no se ajustan a una distribución Normal.
  3. El tercer gráfico, Scale-location o también llamado Spread-Location, muestra si los residuos se distribuyen por igual a lo largo de los rangos de predictores. Permite verificar si la varianza es igual (homocedasticidad). Si se ve una línea horizontal con puntos de dispersión iguales (al azar), es una buena señal.
  4. EL último de los gráficos es el Residuals Vs Leverage. Nos ayuda a encontrar casos influyentes. No todos los valores atípicos influyen en el análisis de regresión lineal. Aunque parezcan valores extremos por salirse de lo habitual, igual no influyen en el modelo. De igual forma, valores que aparentemente confirman el modelo, podrían ser muy influyentes y alterar los resultados si los excluimos del análisis. En este gráfico los patrones no son relevantes. Hay que observar valores periféricos en la esquina superior derecha o en la esquina inferior derecha. Esos lugares son los lugares donde los casos pueden influir en una línea de regresión. Hay que buscar casos fuera de la línea, la distancia de Cook. Los resultados de la regresión se alterarán si excluimos esos casos.

Otra forma de identificar las observaciones que puedan ser outliers o puntos con alta influencia (leverage) es emplear las funciones rstudent() y hatvalues().
La función “rstudent” calcula los residuos Studentizados, que vuelve a normalizar los residuos para tener una varianza unitaria. Típicamente, las desviaciones estándar de los residuos en una muestra varían mucho de un punto de datos a otro, incluso cuando todos los errores tienen la misma desviación estándar, particularmente en el análisis de regresión; por lo tanto, no tiene sentido comparar los residuos en diferentes puntos de datos sin primero Studentizarlos. Se considera que los casos que superan un nivel de 3 son outlayers.

plot(x = modelo_multiple$fitted.values, y = abs(rstudent(modelo_multiple)), main = "Residuos absolutes studentizados vs valores predichos", pch = 20, col = "grey30")
abline(h = 3, col = "red") # se pinta la linea límite de 3

Las observaciones con alto leverage, son observaciones altamente influyentes, puesto que podría estar condicionando el modelo. La eliminación de este tipo de observaciones debe de analizarse con detalle y dependiendo de la finalidad del modelo. Si el fin es predictivo, un modelo sin estas observaciones puede lograr mayor precisión la mayoría de casos. Sin embargo, es muy importante prestar atención a estos valores ya que, de no ser errores de medida, pueden ser los casos más interesantes. El modo adecuado a proceder cuando se sospecha de algún posible valor atípico o influyente es calcular el modelo de regresión incluyendo y excluyendo dicho valor. Observaciones cuyos valores superen 2.5x((p+1)/n), siendo p el número de predictores y n el número de observaciones, deben tenerse en consideración por su posible influencia.

plot(hatvalues(modelo_multiple), main = "Medición de leverage", pch = 20)
# Se añade una línea en el threshold de influencia acorde a la regla 2.5x((p+1)/n)
abline(h = 2.5*((dim(modelo_multiple$model)[2]-1 + 1)/dim(modelo_multiple$model)[1]), col = "red")

En los modelos de regresión lineal con múltiples predictores, además del estudio de los residuos vistos, es necesario descartar colinealidad o multicolinealidad entre variables.

Colinealidad

Para la colinealidad se recomienda calcular el coeficiente de correlación entre cada par de predictores incluidos en el modelo:

require(corrplot) # importa la libreria para generar graficos de correlación
corrplot.mixed(corr = cor(Boston[,c("crim", "zn", "nox", "rm", "dis", "rad", "tax", "ptratio", "black", "lstat", "medv")], method = "pearson")) # grafico con los coeficientes de correlación

El gráfico muestra arriba a la derecha una forma visual de correlación, marcando en azul la correlación positiva y en rojo la negativa. En la parte izquierda/abajo muestra los valores numéricos. Una vez vistas las correlaciones más fuertes, se pueden ver particularmente:

attach(Boston)
par(mfrow = c(2,2))
plot(x = tax, y = rad, pch = 20)
plot(x = tax, y = nox, pch = 20)
plot(x = dis, y = nox, pch = 20)
plot(x = medv, y = rm, pch = 20)

Si la correlación es alta y por lo tanto las variables aportan información redundante, es recomendable analizar si el modelo mejora o no empeora excluyendo alguno de estos predictores.

Multicolinealidad

Para el estudio de la multicolinealidad una de las medidas más utilizadas es el factor de inflación de varianza VIF. Puede calcularse mediante la función vif() del paquete car.

require(car) # importa el paquete car
vif(modelo_multiple) # calcula el factor de inflación de varianza 

Si lo indices VIF son bajos o moderados, valores entre 5 y 10 indican posibles problemas y valores mayores o iguales a 10 se consideran muy problemáticos.

Interacción entre predictores

Una de las asunciones del modelo de regresión lineal múltiple es la de aditividad, según la cual los efectos que causan sobre la variable respuesta Y variaciones en el predictor X_i son independientes del valor que tomen los otros predictores. Se conoce como efecto de interacción cuando el efecto de un predictor varía dependiendo del valor que adquiera otro predictor. Si esto ocurre, el modelo mejorará si se incluye dicha interacción. Si en un modelo se incorpora una interacción, se deben incluir también los predictores individuales que forman la interacción aun cuando por sí solos no sean significativos.

Para simplificar, podemos generar un modelo lineal con dos variables predictoras. El modelo lineal múltiple empleando ambos predictores resulta en:

modelo <- lm(medv  ~ lstat + age, data = Boston) # genera el nuevo modelo
summary(modelo) # muestra los valores del modelo

Como es un modelo con dos predictores continuos se puede representar el plano de regresión:

rango_lstat <- range(Boston$lstat)
nuevos_valores_lstat <- seq(from = rango_lstat[1], to = rango_lstat[2], length.out = 20)
rango_age <- range(Boston$age)
nuevos_valores_age <- seq(from = rango_age[1], to = rango_age[2], length.out = 20)

predicciones <- outer(X = nuevos_valores_lstat, Y = nuevos_valores_age, FUN = function(lstat, age) {
                          predict(object = modelo, newdata = data.frame(lstat, age))
                          })

superficie <- persp(x = nuevos_valores_lstat, y = nuevos_valores_age, z = predicciones, theta = 20, phi = 5,
                    col = "lightblue", shade = 0.1, zlim = range(-10,100), xlab = "lstat", ylab = "age", zlab = "medv",
                    ticktype = "detailed", main = "Predición precio medio ~ lstat y age")

observaciones <- trans3d(Boston$lstat, Boston$age, Boston$medv, superficie)
error <- trans3d(Boston$lstat, Boston$age, fitted(modelo), superficie)
points(observaciones, col = "red", pch = 16)
segments(observaciones$x, observaciones$y, error$x, error$y)

En R se puede generar un modelo con interacción de dos formas: indicando de forma explícita los predictores individuales y entre que predictores se quiere evaluar la interacción

lm(medv ~ lstat + age + lstat:age, data = Boston)

O bien de forma directa

modelo_interaccion  <- lm(medv ~ lstat * age, data = Boston)
summary(modelo_interaccion)

Si el R-squared mejora introduciendo la ineracción, entonces el modelo más adecuado es con la interacción.

0 Seguir leyendo →

Regresión lineal múltiple

Regresión lineal múltiple

La regresión lineal múltiple es la extensión de el modelo de regresión lineal simple.
Este tipo de regresión puede utilizarse cuando queremos conocer la fuerza del efecto que las variables independientes tienen en una variable dependiente. Por ejemplo, el tiempo de revisión, la ansiedad de la prueba, la asistencia a clase y el género, ¿tiene algún efecto en el examen de rendimiento de los estudiantes?
También se utiliza para entender cómo cambia la variable dependiente cuando cambiamos las variables independientes. Por ejemplo, puede indicar cuánto aumenta la presión arterial de una persona por cada cambio en el índice de masa corporal (IMC), manteniendo constante otros factores.

La regresión lineal múltiple utiliza múltiples variables, llamadas variables independientes, o predictores, que mejor predicen el valor de la variable objetivo, que es llamada variable dependiente. En la regresión lineal múltiple, el valor objetivo, y, es una combinación lineal de variables independientes, x. Por lo general, el modelo tiene el formato: y = \theta_0 + \theta_1 \cdot x_1 + \theta_2 \cdot x_2 + \dots + \theta_n \cdot x_n. Matemáticamente, podemos mostrarlo como forma de vector. Esto significa que se puede mostrar como un producto de 2 vectores: el vector de parámetros y el vector de conjunto de características.

Generalmente, podemos mostrar la ecuación de un espacio multidimensional como \theta^{T} \cdot x, donde \theta es un vector de n, y x es el vector de los conjuntos de características, como \theta es un vector de coeficientes, y se supone que se multiplica por x, entonces \theta se muestra transpuestos. \theta es también llamado vector de parámetros o vector de peso de la ecuación de regresión. El primer elemento del conjunto de características se establecería en 1, porque convierte el \theta_0 en el parámetro de intercepción.

La idea es encontrar el mejor vector de parámetros para nuestros datos, como en el caso en la regresión lineal. Para lograr este objetivo, tenemos que minimizar el error de la predicción.

Cálculo de los parámetros de regresión

Para encontrar los parámetros optimizados para nuestro modelo, primero debemos entender cuáles son los parámetros optimizados. En resumen, los parámetros optimizados son los que conducen a un modelo con los errores menos graves. Como en el caso en regresión lineal, podemos decir que el error es la distancia desde el dato puntual hasta el modelo de regresión ajustado. La media de todos los errores muestra como ajusta el modelo al conjunto de datos real. Normalmente utilizamos el MSE (mean squared error), pero no es la única forma de mostrar el error de un modelo de regresión lineal múltiple, solo es una de las formas más populares de hacerlo. El objetivo de la regresión lineal múltiple es minimizar la ecuación de MSE, encontrando los mejores parámetros \theta, pero ¿cómo?

Hay muchas maneras de estimar el valor de estos coeficientes. Sin embargo, los métodos más comunes son los mínimos cuadrados ordinarios y el enfoque de optimización:

  • Los mínimos cuadrados ordinarios tratan de estimar los valores de los coeficientes minimizando el “Mean Square Error”. Utiliza los datos como una matriz y operaciones de álgebra lineal para estimar los valores óptimos. El problema es el tiempo para calcular las operaciones matriciales, ya que puede tardar mucho tiempo en terminar. Cuando el número de filas del conjunto de datos es menos de 10.000 se puede pensar en esta técnica, sin embargo, para valores mayores, se deberían probar otros métodos más rápidos.
  • La segunda opción es utilizar un algoritmo de optimización para buscar los mejores parámetros. Proceso iterativos de optimización de los valores de los coeficientes, minimizando el error del modelo. Por ejemplo, “Gradient Descent”, que inicia la optimización con valores aleatorios para cada coeficiente. A continuación, calcula los errores, e intenta minimizarlo cambiando los coeficientes en múltiples iteraciones. “Gradient Descent” es un enfoque adecuado si se tiene un conjunto de datos grande. Sin embargo, hay otros enfoques para estimar los parámetros de la regresión lineal múltiple que se puede explorar por su cuenta.

Uso del modelo y problemas

Después de que encontramos los parámetros de la ecuación lineal, hacer predicciones es tan simple como resolver la ecuación para un conjunto específico de entradas. Nuestra representación de modelo de regresión lineal para este problema sería: y = \theta^{T} \cdot x.

Como se ha visto, se puede utilizar múltiples variables independientes para predecir un valor objetivo en una regresión lineal múltiple. A veces es mejor modelo que la regresión lineal simple, que utiliza sólo una variable independiente para predecir la variable dependiente. Pero ¿Cuántas variables independientes se deberíamos utilizar para la predicción? ¿Deberíamos utilizar todos los campos de nuestro dataset? ¿Agregar variables independientes a un modelo regresión lineal múltiple siempre aumenta la precisión del módelo?
Básicamente, agregar demasiadas variables independientes sin ninguna justificación teórica puede darnos un modelo sobreajustado, demasiado complicado para el conjunto de datos y nada util para la predicción. Por lo tanto, se recomienda evitar el uso de muchas variables para la predicción. Hay diferentes maneras de evitar el sobreajuste de un modelo en regresión, que veremos en otros artículos.
Otra pregunta es si las variables independientes deben ser continuas. Las variables independientes categóricas pueden incorporarse en un modelo de regresión convirtiéndolas en variables numéricas. Por ejemplo, dada una variable binaria como tipo de coche, el código es “0” para “Manual” y 1 para los autos “automáticos”.
Como último punto, recuerde que la “regresión lineal múltiple” es un tipo específico de regresión lineal. Por lo tanto, tiene que haber una relación lineal entre la variable dependiente y cada una de las variables independientes. Se pueden utilizar diagramas de dispersión y comprobar visualmente la linealidad. Si la relación mostrada en el diagrama de dispersión no es lineal, entonces, debe utilizar regresión no lineal.

Ir al artículo anterior de la serie: Regresión lineal simple

Ir al artículo siguiente de la serie: Evaluación del modelo de regresión

0 Seguir leyendo →

Regresión lineal en R

Regresión simple

require(MASS) # importa la libreria MASS con funciones y métodos estadísticos
require(ISLR) # importa la librería ISLR con datos para un aprender estadística con R
data("Boston") # utiliza el conjunto de datos Boston del paquete MASS. Mediana del valor de la vivienda

# Estudio simple de los datos
require(psych) # importa la librería psych con procedimientos para la investigación psicológica.
summary(Boston) # muestra estadísticos básicos del conjunto de datos
multi.hist(x = Boston[,1:3], dcol = c("blue","red"), dlty = c("dotted", "solid"), main = "") # crea un histograma básico

# Creacion de un modelo simple de regresion para predecir el valor de la vivienda (medv) en función del porcentaje de pobreza de la población (lstat)
modelo_simple = lm(data = Boston,formula = medv ~ lstat)  # genera un modelo de regresión lineal por mínimos cuadrados en el que la variable respuesta es medv y el predictor lstat.
names(modelo_simple) # para ver el contenido de modelo generado
summary(modelo_simple) # para visualizar los principales parámetros del modelo generado

Datos a observar:

  • p-value del estadístico F. Si es bajo (<0.05) significa que hay una relación entre el predictor y la respuesta.
  • RSE (Residual standard error): Son las unidades que se aleja, en promedio, cualquier predicción del modelo. Hay que tener en cuenta el promedio de la variable respuesta, por lo que el RSE se suele medir en porcentaje: $\frac{RSE}{promedio variable respuesta}=X\%$
  • $R^2$: Indica el tanto por uno (multiplicar por 100 para saber el %) de la variabilidad explicada por el modelo. La ventaja de $R^2$ es que es independiente de la escala en la que se mida la variable respuesta, por lo que su interpretación es más sencilla.
  • Intercept($\beta_0$): El valor promedio de la variable respuesta cuando el predictor es 0. Es la ordenada en el origen
  • Predictor($\beta_1$): Por cada unidad que se incrementa el predictor, indica cuanto vale la variable respuesta. Es la pendiente.

Con los coeficientes de regresión ya pueden hacerse estimaciones, pero esos coeficiente no dejan de ser una estimación con un error estándar y un intervalo de confianza. Para calcularlo se utiliza la función:

confint(modelo_simple, level = 0.95)

Nos indicará para la ordenada en el origen y la pendiente, los valores extremos al 2.5% y 97.5%

Estimación de datos con el modelo

Para realizar predicciones hay que tener en cuenta que tienen asociado un error y por lo tanto un intervalo. Es importante diferenciar entre dos tipos de intervalo:

  • Intervalo de confianza: Devuelve un intervalo para el valor promedio de la variable a predecir con un determinado valor del predictor, supóngase 10.
    predict(object = modelo_simple, newdata = data.frame(lstat = c(10)), interval = "confidence", level = 0.95)
    
  • Intervalo de predicción: Devuelve un intervalo para el valor esperado de un valor a predecir con un determinado valor del predictor.
    predict(object = modelo_simple, newdata = data.frame(lstat = c(10)), interval = "prediction", level = 0.95)
    

Ambos intervalos estarán centrados en torno al mismo valor. Y, aunque parezcan similares, la diferencia se encuentra en que los intervalos de confianza se aplican al valor promedio que se espera de y para un determinado valor de x, mientras que los intervalos de predicción no se aplican al promedio. Por esta razón, los segundos siempre son más amplios que los primeros.

Representación gráfica

La creación de un modelo de regresión lineal simple suele acompañarse de una representación gráfica superponiendo las observaciones con el modelo. Además de ayudar a la interpretación, es el primer paso para identificar posibles violaciones de las condiciones de la regresión lineal.

attach(Boston)
plot(x = lstat, y = medv, main = "medv vs lstat", pch = 20, col = "grey30") # Pinta las observaciones
abline(modelo_simple, lwd = 3, col = "red") # Pinta la linea de regresión

Una de las mejores formas de confirmar que las condiciones necesarias para un modelo de regresión lineal simple por mínimos cuadrados se cumplen es mediante el estudio de los residuos del modelo.
En R, los residuos se almacenan dentro del modelo bajo el nombre de residuals. R genera automáticamente los gráficos más típicos para la evaluación de los residuos de un modelo.

Estudio de los residuos del modelo.

Para confirmar que un modelo de regresión lineal simple por mínimos cuadrados cumple su labor, lo mejor es estudiar los residuos del modelo. En R, los residuos se almacenan dentro del modelo, bajo el nombre de “residuals”, además, R puede generar los gráficos más usados para la evaluar los residuos del modelo:

par(mfrow = c(1,2)) # Indicamos que queremos 2 gráficos por pantalla (1 fila y 2 columnas)
plot(modelo_simple) # Pintamos los graficos de residuos

Aparecen 4 gráficos:

  1. El primer gráfico muestra los residuos para cada predicción. Si hay una distribución lineal de los residuos, entonces podemos pensar que el modelo se ajusta bien. Si se observa cualquier tipo de distribución no lineal ni constante, podemos sospechar que el modelo no se ajusta del todo.
  2. El segundo gráfico es de tipo Normal Q-Q. Compara los residuos estandarizados con la distribución teorica Normal. Si los puntos se alejan de la linea normal, indica que los residuos no se ajustan a una distribución Normal.
  3. El tercer gráfico, Scale-location o también llamado Spread-Location, muestra si los residuos se distribuyen por igual a lo largo de los rangos de predictores. Permite verificar si la varianza es igual (homocedasticidad). Si se ve una línea horizontal con puntos de dispersión iguales (al azar), es una buena señal.
  4. EL último de los gráficos es el Residuals Vs Leverage. Nos ayuda a encontrar casos influyentes. No todos los valores atípicos influyen en el análisis de regresión lineal. Aunque parezcan valores extremos por salirse de lo habitual, igual no influyen en el modelo. De igual forma, valores que aparentemente confirman el modelo, podrían ser muy influyentes y alterar los resultados si los excluimos del análisis. En este gráfico los patrones no son relevantes. Hay que observar valores periféricos en la esquina superior derecha o en la esquina inferior derecha. Esos lugares son los lugares donde los casos pueden influir en una línea de regresión. Hay que buscar casos fuera de la línea, la distancia de Cook. Los resultados de la regresión se alterarán si excluimos esos casos.

Otra forma de identificar las observaciones que puedan ser outliers o puntos con alta influencia (leverage) es emplear las funciones rstudent() y hatvalues().
La función “rstudent” calcula los residuos Studentizados, que vuelve a normalizar los residuos para tener una varianza unitaria. Típicamente, las desviaciones estándar de los residuos en una muestra varían mucho de un punto de datos a otro, incluso cuando todos los errores tienen la misma desviación estándar, particularmente en el análisis de regresión; por lo tanto, no tiene sentido comparar los residuos en diferentes puntos de datos sin primero Studentizarlos. Se considera que los casos que superan un nivel de 3 son outlayers.

plot(x = modelo_simple$fitted.values, y = abs(rstudent(modelo_simple)), main = "Residuos absolutes studentizados vs valores predichos", pch = 20, col = "grey30")
abline(h = 3, col = "red") # se pinta la linea límite de 3

Las observaciones con alto leverage, son observaciones altamente influyentes, puesto que podría estar condicionando el modelo. La eliminación de este tipo de observaciones debe de analizarse con detalle y dependiendo de la finalidad del modelo. Si el fin es predictivo, un modelo sin estas observaciones puede lograr mayor precisión la mayoría de casos. Sin embargo, es muy importante prestar atención a estos valores ya que, de no ser errores de medida, pueden ser los casos más interesantes. El modo adecuado a proceder cuando se sospecha de algún posible valor atípico o influyente es calcular el modelo de regresión incluyendo y excluyendo dicho valor. Observaciones cuyos valores superen 2.5x((p+1)/n), siendo p el número de predictores y n el número de observaciones, deben tenerse en consideración por su posible influencia.

plot(hatvalues(modelo_simple), main = "Medición de leverage", pch = 20)
# Se añade una línea en el threshold de influencia acorde a la regla 2.5x((p+1)/n)
abline(h = 2.5*((dim(modelo_simple$model)[2]-1 + 1)/dim(modelo_simple$model)[1]), col = "red")
0 Seguir leyendo →

Regresión lineal en Pyton

Importación de los paquetes básicos

import matplotlib.pyplot as plt # para crear graficos
import pandas as pd             # herramientas para analisis de datos y estructuras de datos
import pylab as pl              # añade numpy+scipy+sympy+pandas+matplotlib+ipython = MatLab
import numpy as np              # paquete básico para calculos científicos
%matplotlib inline              # muestra los graficos en la linea de comandos de Python

Descarga del fichero de datos

!wget -O FuelConsumption.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/FuelConsumptionCo2.csv
df = pd.read_csv("FuelConsumption.csv")
df.head() # mostramos los primeros datos 
MODELYEAR MAKE MODEL VEHICLECLASS ENGINESIZE CYLINDERS TRANSMISSION FUELTYPE FUELCONSUMPTION_CITY FUELCONSUMPTION_HWY FUELCONSUMPTION_COMB FUELCONSUMPTION_COMB_MPG CO2EMISSIONS
0 2014 ACURA ILX COMPACT 2.0 4 AS5 Z 9.9 6.7 8.5 33 196
1 2014 ACURA ILX COMPACT 2.4 4 M6 Z 11.2 7.7 9.6 29 221
2 2014 ACURA ILX HYBRID COMPACT 1.5 4 AV7 Z 6.0 5.8 5.9 48 136
3 2014 ACURA MDX 4WD SUV – SMALL 3.5 6 AS6 Z 12.7 9.1 11.1 25 255
4 2014 ACURA RDX AWD SUV – SMALL 3.5 6 AS6 Z 12.1 8.7 10.6 27 244

Listamos los estadísticos principales para cada variable

df.describe()
MODELYEAR ENGINESIZE CYLINDERS FUELCONSUMPTION_CITY FUELCONSUMPTION_HWY FUELCONSUMPTION_COMB FUELCONSUMPTION_COMB_MPG CO2EMISSIONS
count 1067.0 1067.000000 1067.000000 1067.000000 1067.000000 1067.000000 1067.000000 1067.000000
mean 2014.0 3.346298 5.794752 13.296532 9.474602 11.580881 26.441425 256.228679
std 0.0 1.415895 1.797447 4.101253 2.794510 3.485595 7.468702 63.372304
min 2014.0 1.000000 3.000000 4.600000 4.900000 4.700000 11.000000 108.000000
25% 2014.0 2.000000 4.000000 10.250000 7.500000 9.000000 21.000000 207.000000
50% 2014.0 3.400000 6.000000 12.600000 8.800000 10.900000 26.000000 251.000000
75% 2014.0 4.300000 8.000000 15.550000 10.850000 13.350000 31.000000 294.000000
max 2014.0 8.400000 12.000000 30.200000 20.500000 25.800000 60.000000 488.000000

Selecciona algunas variables para verlas con más detalle.

cdf = df[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_COMB','CO2EMISSIONS']]
cdf.head(9)
ENGINESIZE CYLINDERS FUELCONSUMPTION_COMB CO2EMISSIONS
0 2.0 4 8.5 196
1 2.4 4 9.6 221
2 1.5 4 5.9 136
3 3.5 6 11.1 255
4 3.5 6 10.6 244
5 3.5 6 10.0 230
6 3.5 6 10.1 232
7 3.7 6 11.1 255
8 3.7 6 11.6 267

Para verlas mejor, podemos dibujar cada una de esas verialbes

viz = cdf[['CYLINDERS','ENGINESIZE','CO2EMISSIONS','FUELCONSUMPTION_COMB']]
viz.hist()
plt.show()

Comparamos cada variable con la emisión de carbono, para ver si se pueden relacionar linealmente

plt.scatter(cdf.FUELCONSUMPTION_COMB, cdf.CO2EMISSIONS,  color='blue')
plt.xlabel("FUELCONSUMPTION_COMB")
plt.ylabel("Emission")
plt.show()

plt.scatter(cdf.ENGINESIZE, cdf.CO2EMISSIONS,  color='blue')
plt.xlabel("Engine size")
plt.ylabel("Emission")
plt.show()

plt.scatter(cdf.CYLINDERS, cdf.CO2EMISSIONS,  color='blue')
plt.xlabel("Cylinders")
plt.ylabel("Emission")
plt.show()


Creamos un conjunto de datos de entrenamiento y otro de prueba

Se divide el conjunto de datos en uno de entrenamiento y otro de pruebas, siendo excluyentes. Esto permite una evaluación más exacta, ya que los datos de entrenamiento no son parte de los datos que se usaran para comprobar el modelo.

msk = np.random.rand(len(df)) < 0.8
train = cdf[msk]
test = cdf[~msk]

Modelado de datos usando el paquete sklearn

from sklearn import linear_model #  importación del paquete sklearn
train_x = np.asanyarray(train[['ENGINESIZE']]) # conjunto de datos independientes
train_y = np.asanyarray(train[['CO2EMISSIONS']]) # conjunto de datos dependientes 
regr = linear_model.LinearRegression() # uso del modelo de regresion lineal
regr.fit (train_x, train_y) # ejecución de los calculos
print ('Pendiente: ', regr.coef_) # muestra la pendiente
print ('Ordenada: ',regr.intercept_) # muestra la ordenada en el origen

Pendiente: [[39.071235]]
Ordenada: [126.65808636]

Pintamos el ajuste realizado

plt.scatter(train.ENGINESIZE, train.CO2EMISSIONS,  color='blue')
plt.plot(train_x, regr.coef_[0][0]*train_x + regr.intercept_[0], '-r')
plt.xlabel("Engine size")
plt.ylabel("Emission")

Se comparan los valores actuales con los predichos para calcular la exactitud del modelo de regresión

Existen distintas métricas de evaluación de modelos, utilicemos MSE para calcular la exactitud de nuestro modelo basado en el set de prueba:
– Error medio absoluto: Es una media del valor absoluto de los errores. Es la métrica más fácil de comprender ya que simplemente es el promedio de los errores pero en valor absoluto para que errores negativos no compensen los positivos.
– Error Cuadrado Medio (MSE): Es la media de los errores al cuadrado. Es más popular que el error medio absoluto porque hace que los grandes errores tengan más peso.
– R-cuadráticono es un error, es una medida popular que indica la precisión del modelo. Representa como de cerca están los datos de la linea de regresión. Mientras más alto es el R-cuadrático, mejor ajusta el modelo respecto de los datos. El máximo valor posible es 1 y puede tomar valores negativos.

from sklearn.metrics import r2_score # importación del paquete metrics de sklearn
test_x = np.asanyarray(test[['ENGINESIZE']]) # conjunto de datos independientes
test_y = np.asanyarray(test[['CO2EMISSIONS']]) # conjunto de datos dependientes
test_y_ = regr.predict(test_x) # ejecución de los calculos
print("Error medio absoluto: %.2f" % np.mean(np.absolute(test_y_ - test_y)))
print("Error cuadrado medio (MSE): %.2f" % np.mean((test_y_ - test_y) ** 2))
print("R2-cuadrático: %.2f" % r2_score(test_y_ , test_y) )

Error medio absoluto: 23.04
Error cuadrado medio (MSE): 894.25
R2-score: 0.70

0 Seguir leyendo →

Regresión lineal simple

Regresión lineal simple

La pregunta que trata de responder la regresión linea simple es: Dado un conjunto de datos, ¿Podemos predecir una de las variables, utilizando otro campo?
La respuesta es sí: Podemos utilizar la regresión lineal para predecir un valor continuo utilizando otras variables. La regresión lineal es la aproximación de un modelo lineal que se utiliza para describir la relación entre dos o más variables. En la regresión lineal simple, hay dos variables: una variable dependiente y una variable independiente. El punto clave en la regresión lineal es que nuestro valor dependiente debe ser continuo y no puede ser un valor discreto. Sin embargo, las variables independientes pueden ser medidas en una escala de medida categórica o continua.

Existen dos tipos de modelos de regresión lineal: regresión simple y regresión múltiple.La regresión lineal simple es cuando se utiliza una variable independiente para estimar una variable dependiente. Cuando se utiliza más de una variable independiente, el proceso se denomina regresión lineal múltiple.

La mejor manera de entender la regresión lineal es dibujando nuestras variables. Vamos a usar el tamaño del motor regresión lineal simplecomo una variable independiente, y la Emisión como el valor objetivo que queremos predecir. Un diagrama de dispersión muestra la relación entre estas variables. Además, se ve que estas variables están relacionadas linealmente. Con la regresión lineal, se puede ajustar una línea a través de los datos.

La línea de ajuste se muestra tradicionalmente como un polinomio. En un problema de regresión simple (una sola variable independiente), la forma del modelo sería y = \theta_0 + \theta_1 \cdot x_1. En esta ecuación, “y” es la variable dependiente (valor pronosticado), x_1 es la variable independiente, \theta_1 es conocida como “pendiente” y el valor \theta_0 se conoce como  “ordenada en el origen”. \theta_0 y \theta_1 son los coeficientes de la ecuación lineal.

Calculo de los coeficientes

Ahora la preguntas es ¿Cómo se determina cuál de las líneas “encaja mejor”? ¿Cómo calcular \theta_0 y \theta_1 para encontrar la mejor línea para “ajustar” los datos?.
Supongamos que ya hemos encontrado la mejor línea de ajuste para nuestros datos. Solo nos faltaría comprobar lo bien que se ajustan los datos reales con esta línea. Esto significa que si para un elemento de la muestra tenemos un valor de la variable independiente, la variabe dependiente calculada debe aproximarse muy cerca del valor real. Esto no suele ser así, ya que siempre suele existir un error, y esto significa que nuestra línea de predicción no es precisa. Este error se denomina error residual.

Podemos decir que el error es la distancia desde el punto de datos hasta la línea de regresión ajustada y que la media de todos los errores residuales muestra lo mal que encaja la línea con todo el conjunto de datos. Matemáticamente, es calculado por la ecuación del error de cuadrado medio (ECM), o en inglés “mean squared error” (MSE). El objetivo es encontrar una línea en la que se minimice la media de todos estos errores.

    \[ MSE=\frac{1}{n}\sum_{i=1}^{n}{(y_i-y'_i)^2} \]

Podemos utilizar unas fórmulas matemáticas para calcular \theta_0 y \theta_1:

\theta_1 = \frac{\sum_{i=1}^{s}{(x_i -\overline{x}) \cdot (y_i -\overline{y})}}{\sum_{i=1}^{s}{(x_i -\overline{x})^2}}

\theta_0 = \overline{y} - \theta_1 \cdot \overline{x}

Se requiere que calculemos la media de las columnas independientes y dependientes de todo el conjunto de datos, por lo que todos los datos deben estar disponibles. Una vez calculada la media, se estima el valor de \theta_1 y luego con ese valor calcular \theta_0.

Realmente no necesitas recordar la fórmula para el cálculo de estos parámetros, la mayoría de las librerias usadas para el aprendizaje automático en Python, R, y Scala pueden encontrar fácilmente estos parámetros. Pero siempre es bueno entender cómo funciona. (VER EJEMPLO EN PYTHON)

Después de que encontramos los parámetros de la ecuación lineal, hacer predicciones es tan simple como solucionar la ecuación para un conjunto específico de entradas.

Utilidad de la regresión lineal simple

La regresión lineal es la más básica que hay que utilizar y entender. Es muy útil, ya que es rápida y no requiere ajuste de parámetros como ocurre en otros cálculos de predicción donde hay que ajustar el parámetro K en los K-Vecinos mas cercanos o la tasa de aprendizaje en las Redes Neuronales. La regresión lineal también es fácil de entender y altamente interpretables.

Ir al artículo anterior de la serie: Introducción al Modelo de Regresión

Ir al artículo siguiente de la serie: Regresión lineal múltiple

0 Seguir leyendo →

Introducción al Modelo de Regresión

Introducción al modelo de regresión.

Tabla de datos de cochesPara la introducción al modelo de regresión, vamos a utilizar el conjunto de datos que se muestra. Estos estan relacionados con las emisiones de Co2 de los diferentes coches. Incluye el tamaño del motor, el número de cilíndros, el consumo de combustible y las emisiones de Co2 de varios modelos. La pregunta es, “Dado este conjunto de datos, podemos predecir la emisión Co2 de un coche utilizando otros campos como, por ejemplo, EngineSize o Cylinders?”

Supongamos que tenemos algunos datos históricos de diferentes coches, y suponemos que uno de ellos aún no se ha fabricado, pero estamos interesados en la estimación de su emisión de Co2, después de la producción. ¿Es posible? Podemos utilizar métodos de regresión para predecir un valor continuo, como por ejemplo Emisión de CO2, algunas otras variables.

La regresión es el proceso de predicción de un valor continuo. En la regresión hay dos tipos de variables: una variable dependiente y una o más independientes. La variable dependiente se puede ver como el “estado”, el “objetivo” o “el objetivo final” que estudiamos y tratamos de predecir, y las variables independientes, también conocidas como variables explicativas, pueden ser la “causa” de los “estados”. Las variables independientes se muestran convencionalmente por x; y la variable dependiente es denotada por y. Un modelo de regresión se refiere a y, o a la variable dependiente, a una función de x, es decir, a las variables independientes.

El punto clave de la regresión es que nuestro valor dependiente debe ser continuo, y no puede ser un valor discreto. Sin embargo, la variable independiente o las variables se pueden medir en categóricas o escala de medición continua. Por lo tanto, lo que queremos hacer aquí es usar los datos históricos de algunos coches, usando uno o más de sus características, y a partir de esos datos, hacer un modelo. Utilizamos la regresión para construir un modelo de regresión/estimación. A continuación, el modelo se utiliza para predecir la emisión de Co2 esperada para un coche nuevo o desconocido.

Básicamente, hay 2 tipos de modelos de regresión: regresión simple y regresión múltiple.

La regresión simple es cuando se utiliza una variable independiente para estimar una variable dependiente. Puede ser lineal en no lineales. Por ejemplo, pronosticar la emisión de Co2emisiones utilizando la variable EngineSize. La linealidad de la regresión se basa en la naturaleza de la relación entre la independencia y la dependencia variables. Cuando hay más de una variable independiente presente, el proceso se llama regresión múltiple lineal. Por ejemplo, predicando Co2emisiones utilizando EngineSize y el número de Cylinders en cualquier coche dado. De nuevo, en función de la relación entre las variables dependientes e independientes, puede ser regresión lineal o no lineal.

Examinemos algunas aplicaciones de muestra de regresión. Esencialmente, utilizamos la regresión cuando queremos estimar un valor continuo. Por ejemplo, una de las aplicaciones del análisis de regresión podría estar en el área de la previsión de ventas. Puede intentar predecir las ventas anuales totales de un vendedor de variables independientes como, por ejemplo, como la edad, la educación y los años de experiencia. También se puede utilizar en el campo de la psicología, por ejemplo, para determinar la satisfacción individual basado en factores demográficos y psicológicos. Podemos utilizar el análisis de regresión para predecir el precio de una casa en un área, basada en su tamaño, número de habitaciones, y así sucesivamente. Incluso podemos usarlo para predecir el ingreso de empleo para las variables independientes, como las horas de trabajo, educación, ocupación, sexo, edad, años de experiencia, etc.

Se pueden encontrar muchos ejemplos de la utilidad del análisis de regresión en estos y muchos otros campos o dominios, como las finanzas, la salud, las ventas, y más. Tenemos muchos algoritmos de regresión. Cada uno de ellos tiene su propia importancia y una condición específica a la que su aplicación es las más adecuado:

  • Ordinal regression
  • Poisson regression
  • Fast forest quantile regression
  • Linear, Polynomial, Lasso, Stepwise, Ridge regression
  • Bayesian linear regression
  • Neural network regression
  • Decision forest regression
  • Boosted decision tree regression
  • KNN (K-nearest neighbors)

 

Ir al artículo anterior de la serie: Aprendizaje Supervisado y No Supervisado

Ir al artículo siguiente de la serie:Regresión lineal simple

0 Seguir leyendo →