Los modelos de regresión se ajustan a los datos de entrenamiento mediante regresión lineal y algoritmos de optimización de búsqueda local.
Los modelos como la regresión lineal y la regresión logística se entrenan mediante la optimización de mínimos cuadrados, y este es el enfoque más eficiente para encontrar coeficientes que minimicen el error para estos modelos.
Sin embargo, es posible utilizar alternativas algoritmos de optimización para adaptarse a un modelo de regresión a un conjunto de datos de entrenamiento. Este puede ser un ejercicio útil para aprender más sobre cómo funciona la regresión y la naturaleza central de la optimización en el aprendizaje automático aplicado. También puede ser necesario para la regresión con datos que no cumplen los requisitos de un procedimiento de optimización de mínimos cuadrados.
En este tutorial, descubrirá cómo optimizar manualmente los coeficientes de los modelos de regresión.
Después de completar este tutorial, sabrá:
- Cómo desarrollar los modelos de inferencia para la regresión desde cero.
- Cómo optimizar los coeficientes de un modelo de regresión lineal para predecir valores numéricos.
- Cómo optimizar los coeficientes de un modelo de regresión logística utilizando escalada estocástica.
Empecemos.
Cómo utilizar algoritmos de optimización para ajustar manualmente modelos de regresión
Foto de Christian Collins, algunos derechos reservados.
Descripción general del tutorial
Este tutorial se divide en tres partes; son:
- Optimizar modelos de regresión
- Optimizar un modelo de regresión lineal
- Optimizar un modelo de regresión logística
Optimizar modelos de regresión
Los modelos de regresión, como la regresión lineal y la regresión logística, son algoritmos bien entendidos del campo de la estadística.
Ambos algoritmos son lineales, lo que significa que la salida del modelo es una suma ponderada de las entradas. La regresión lineal está diseñada para «regresión«Problemas que requieren la predicción de un número, y la regresión logística está diseñada para»clasificación”Problemas que requieren una etiqueta de clase para poder predecirse.
Estos modelos de regresión implican el uso de un algoritmo de optimización para encontrar un conjunto de coeficientes para cada entrada del modelo que minimiza el error de predicción. Debido a que los modelos son lineales y se entienden bien, se pueden utilizar algoritmos de optimización eficientes.
En el caso de la regresión lineal, los coeficientes se pueden encontrar mediante la optimización de mínimos cuadrados, que se puede resolver mediante álgebra lineal. En el caso de la regresión logística, se suele utilizar un algoritmo de optimización de búsqueda local.
Es posible utilizar cualquier algoritmo de optimización arbitrario para entrenar modelos de regresión lineal y logística.
Es decir, podemos definir un modelo de regresión y usar un algoritmo de optimización dado para encontrar un conjunto de coeficientes para el modelo que resulten en un mínimo de error de predicción o un máximo de precisión de clasificación.
Se espera que el uso de algoritmos de optimización alternativos sea menos eficiente en promedio que el uso de la optimización recomendada. Sin embargo, puede ser más eficiente en algunos casos específicos, como si los datos de entrada no cumplen con las expectativas del modelo como una distribución gaussiana y no están correlacionados con las entradas externas.
También puede ser un ejercicio interesante para demostrar la naturaleza central de la optimización en el entrenamiento de algoritmos de aprendizaje automático, y específicamente modelos de regresión.
A continuación, exploremos cómo entrenar un modelo de regresión lineal utilizando la escalada estocástica.
Optimizar un modelo de regresión lineal
El modelo de regresión lineal podría ser el modelo predictivo más simple que aprende de los datos.
El modelo tiene un coeficiente para cada entrada y la salida prevista son simplemente los pesos de algunas entradas y coeficientes.
En esta sección, optimizaremos los coeficientes de un modelo de regresión lineal.
Primero, definamos un problema de regresión sintética que podamos usar como foco de optimización del modelo.
Podemos usar la función make_regression () para definir un problema de regresión con 1,000 filas y 10 variables de entrada.
El siguiente ejemplo crea el conjunto de datos y resume la forma de los datos.
|
# definir un conjunto de datos de regresión de sklearn.conjuntos de datos importar hacer_regresión # definir conjunto de datos X, y = make_regression(n_samples=1000, n_features=10, n_informativo=2, ruido=0,2, estado_aleatorio=1) # resumir la forma del conjunto de datos impresión(X.forma, y.forma) |
La ejecución del ejemplo imprime la forma del conjunto de datos creado, lo que confirma nuestras expectativas.
A continuación, necesitamos definir un modelo de regresión lineal.
Antes de optimizar los coeficientes del modelo, debemos desarrollar el modelo y nuestra confianza en cómo funciona.
Comencemos por desarrollar una función que calcule la activación del modelo para una fila de datos de entrada determinada del conjunto de datos.
Esta función tomará la fila de datos y los coeficientes del modelo y calculará la suma ponderada de la entrada con la adición de un coeficiente de intersección con el eje y adicional (también llamado compensación o sesgo). los predecir fila () función a continuación implementa esto.
Estamos usando listas de Python simples y un estilo de programación imperativo en lugar de matrices NumPy o compresiones de listas intencionalmente para hacer que el código sea más legible para los principiantes de Python. Siéntase libre de optimizarlo y publicar su código en los comentarios a continuación.
|
# regresión lineal def predecir fila(fila, coeficientes): # agrega el sesgo, el último coeficiente resultado = coeficientes[[–1] # agregue la entrada ponderada para yo en rango(len(fila)): resultado + = coeficientes[[yo] * fila[[yo] regreso resultado |
A continuación, podemos llamar al predecir fila () función para cada fila en un conjunto de datos dado. los predict_dataset () función a continuación implementa esto.
Nuevamente, estamos usando intencionalmente un estilo de codificación imperativo simple para facilitar la lectura en lugar de las compresiones de listas.
|
# use coeficientes de modelo para generar predicciones para un conjunto de datos de filas def predict_dataset(X, coeficientes): yhats = lista() para fila en X: # Haz una predicción yhat = predecir fila(fila, coeficientes) # almacenar la predicción yhats.adjuntar(yhat) regreso yhats |
Finalmente, podemos usar el modelo para hacer predicciones en nuestro conjunto de datos sintéticos para confirmar que todo funciona correctamente.
Podemos generar un conjunto aleatorio de coeficientes de modelo usando la función rand ().
Recuerde que necesitamos un coeficiente para cada entrada (diez entradas en este conjunto de datos) más un peso adicional para el coeficiente de intersección con el eje y.
|
... # definir conjunto de datos X, y = make_regression(n_samples=1000, n_features=10, n_informativo=2, ruido=0,2, estado_aleatorio=1) # determinar el número de coeficientes n_coeff = X.forma[[1] + 1 # generar coeficientes aleatorios coeficientes = rand(n_coeff) |
Luego, podemos usar estos coeficientes con el conjunto de datos para hacer predicciones.
|
... # generar predicciones para el conjunto de datos yhat = predict_dataset(X, coeficientes) |
Podemos evaluar el error cuadrático medio de estas predicciones.
|
... # calcular el error de predicción del modelo Puntuación = error medio cuadrado(y, yhat) impresión(‘MSE:% f’ % Puntuación) |
Eso es todo.
Podemos unir todo esto y demostrar nuestro modelo de regresión lineal para el modelado predictivo de regresión. El ejemplo completo se enumera a continuación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 dieciséis 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
# modelo de regresión lineal de numpy.aleatorio importar rand de sklearn.conjuntos de datos importar make_regression de sklearn.métrica importar mean_squared_error # regresión lineal def predecir fila(fila, coeficientes): # agrega el sesgo, el último coeficiente resultado = coeficientes[[–1] # agregue la entrada ponderada para yo en rango(len(fila)): resultado + = coeficientes[[yo] * fila[[yo] regreso resultado # use coeficientes de modelo para generar predicciones para un conjunto de datos de filas def predict_dataset(X, coeficientes): yhats = lista() para fila en X: # Haz una predicción yhat = predecir fila(fila, coeficientes) # almacenar la predicción yhats.adjuntar(yhat) regreso yhats # definir conjunto de datos X, y = make_regression(n_samples=1000, n_features=10, n_informativo=2, ruido=0,2, estado_aleatorio=1) # determinar el número de coeficientes n_coeff = X.forma[[1] + 1 # generar coeficientes aleatorios coeficientes = rand(n_coeff) # generar predicciones para el conjunto de datos yhat = predict_dataset(X, coeficientes) # calcular el error de predicción del modelo Puntuación = error medio cuadrado(y, yhat) impresión(‘MSE:% f’ % Puntuación) |
La ejecución del ejemplo genera una predicción para cada ejemplo en el conjunto de datos de entrenamiento y luego imprime el error cuadrático medio de las predicciones.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o procedimiento de evaluación, o las diferencias en la precisión numérica. Considere ejecutar el ejemplo varias veces y compare el resultado promedio.
Esperaríamos un gran error dado un conjunto de pesos aleatorios, y eso es lo que vemos en este caso, con un valor de error de aproximadamente 7,307 unidades.
Ahora podemos optimizar los coeficientes del conjunto de datos para lograr un error bajo en este conjunto de datos.
Primero, necesitamos dividir el conjunto de datos en conjuntos de prueba y de tren. Es importante retener algunos datos que no se utilizan en la optimización del modelo para que podamos preparar una estimación razonable del rendimiento del modelo cuando se utilizan para hacer predicciones sobre nuevos datos.
Usaremos el 67 por ciento de los datos para el entrenamiento y el 33 por ciento restante como un conjunto de prueba para evaluar el desempeño del modelo.
|
... # dividido en conjuntos de prueba de trenes X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0,33) |
A continuación, podemos desarrollar un algoritmo de escalada estocástico.
El algoritmo de optimización requiere una función objetivo para optimizar. Debe tomar un conjunto de coeficientes y devolver una puntuación que se minimizará o maximizará correspondiente a un modelo mejor.
En este caso, evaluaremos el error cuadrático medio del modelo con un conjunto determinado de coeficientes y devolveremos la puntuación de error, que debe minimizarse.
los objetivo() La función siguiente implementa esto, dado el conjunto de datos y un conjunto de coeficientes, y devuelve el error del modelo.
|
# función objetiva def objetivo(X, y, coeficientes): # generar predicciones para el conjunto de datos yhat = predict_dataset(X, coeficientes) # calcular la precisión Puntuación = error medio cuadrado(y, yhat) regreso Puntuación |
A continuación, podemos definir el algoritmo estocástico de escalada de colinas.
El algoritmo requerirá una solución inicial (por ejemplo, coeficientes aleatorios) y seguirá haciendo pequeños cambios en la solución de forma iterativa y verificando si da como resultado un modelo de mejor rendimiento. La cantidad de cambio realizado en la solución actual se controla mediante un hiperparámetro step_size. Este proceso continuará durante un número fijo de iteraciones, también proporcionado como un hiperparámetro.
los Montañismo() La función siguiente implementa esto, tomando el conjunto de datos, la función objetivo, la solución inicial y los hiperparámetros como argumentos y devuelve el mejor conjunto de coeficientes encontrados y el rendimiento estimado.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 dieciséis 17 |
# algoritmo de búsqueda local de escalada def Montañismo(X, y, objetivo, solución, nitro, Numero de pie): # evaluar el punto inicial solution_eval = objetivo(X, y, solución) # corre la subida de la colina para yo en rango(nitro): # Da un paso candidato = solución + randn(len(solución)) * paso_Talla # evaluar el punto candidato candidte_eval = objetivo(X, y, candidato) # comprobar si debemos mantener el nuevo punto Si candidte_eval <= solution_eval: # almacenar el nuevo punto solución, solution_eval = candidato, sincero_eval # informe de progreso impresión(‘>% d% .5f’ % (yo, solution_eval)) regreso [[solución, solution_eval] |
Luego podemos llamar a esta función, pasando un conjunto inicial de coeficientes como la solución inicial y el conjunto de datos de entrenamiento como el conjunto de datos para optimizar el modelo.
|
... # definir las iteraciones totales nitro = 2000 # definir el tamaño máximo de paso Numero de pie = 0,15 # determinar el número de coeficientes n_coef = X.forma[[1] + 1 # definir la solución inicial solución = rand(n_coef) # realizar la búsqueda de escalada coeficientes, Puntuación = Montañismo(X_train, y_train, objetivo, solución, nitro, Numero de pie) impresión(‘¡Hecho!’) impresión(‘Coeficientes:% s’ % coeficientes) impresión(‘Entrenar MSE:% f’ % (Puntuación)) |
Finalmente, podemos evaluar el mejor modelo en el conjunto de datos de prueba e informar el rendimiento.
|
... # generar predicciones para el conjunto de datos de prueba yhat = predict_dataset(X_test, coeficientes) # calcular la precisión Puntuación = error medio cuadrado(y_test, yhat) impresión(‘Prueba MSE:% f’ % (Puntuación)) |
Al unir esto, el ejemplo completo de optimización de los coeficientes de un modelo de regresión lineal en el conjunto de datos de regresión sintética se enumera a continuación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 dieciséis 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 sesenta y cinco 66 67 68 69 70 71 72 73 74 |
# optimizar los coeficientes de regresión lineal para el conjunto de datos de regresión de numpy.aleatorio importar randn de numpy.aleatorio importar rand de sklearn.conjuntos de datos importar make_regression de sklearn.model_selection importar train_test_split de sklearn.métrica importar mean_squared_error # regresión lineal def predecir fila(fila, coeficientes): # agrega el sesgo, el último coeficiente resultado = coeficientes[[–1] # agregue la entrada ponderada para yo en rango(len(fila)): resultado + = coeficientes[[yo] * fila[[yo] regreso resultado # use coeficientes de modelo para generar predicciones para un conjunto de datos de filas def predict_dataset(X, coeficientes): yhats = lista() para fila en X: # Haz una predicción yhat = predecir fila(fila, coeficientes) # almacenar la predicción yhats.adjuntar(yhat) regreso yhats # función objetiva def objetivo(X, y, coeficientes): # generar predicciones para el conjunto de datos yhat = predict_dataset(X, coeficientes) # calcular la precisión Puntuación = error medio cuadrado(y, yhat) regreso Puntuación # algoritmo de búsqueda local de escalada def Montañismo(X, y, objetivo, solución, nitro, Numero de pie): # evaluar el punto inicial solution_eval = objetivo(X, y, solución) # corre la subida de la colina para yo en rango(nitro): # Da un paso candidato = solución + randn(len(solución)) * paso_Talla # evaluar el punto candidato candidte_eval = objetivo(X, y, candidato) # comprobar si debemos mantener el nuevo punto Si candidte_eval <= solution_eval: # almacenar el nuevo punto solución, solution_eval = candidato, sincero_eval # informe de progreso impresión(‘>% d% .5f’ % (yo, solution_eval)) regreso [[solución, solution_eval] # definir conjunto de datos X, y = make_regression(n_samples=1000, n_features=10, n_informativo=2, ruido=0,2, estado_aleatorio=1) # dividido en conjuntos de prueba de trenes X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0,33) # definir las iteraciones totales nitro = 2000 # definir el tamaño máximo de paso Numero de pie = 0,15 # determinar el número de coeficientes n_coef = X.forma[[1] + 1 # definir la solución inicial solución = rand(n_coef) # realizar la búsqueda de escalada coeficientes, Puntuación = Montañismo(X_train, y_train, objetivo, solución, nitro, Numero de pie) impresión(‘¡Hecho!’) impresión(‘Coeficientes:% s’ % coeficientes) impresión(‘Entrenar MSE:% f’ % (Puntuación)) # generar predicciones para el conjunto de datos de prueba yhat = predict_dataset(X_test, coeficientes) # calcular la precisión Puntuación = error medio cuadrado(y_test, yhat) impresión(‘Prueba MSE:% f’ % (Puntuación)) |
La ejecución del ejemplo informará el número de iteración y el error cuadrático medio cada vez que se realice una mejora en el modelo.
Al final de la búsqueda, se informa el rendimiento del mejor conjunto de coeficientes en el conjunto de datos de entrenamiento y se calcula y se informa el rendimiento del mismo modelo en el conjunto de datos de prueba.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o procedimiento de evaluación, o diferencias en la precisión numérica. Considere ejecutar el ejemplo varias veces y compare el resultado promedio.
En este caso, podemos ver que el algoritmo de optimización encontró un conjunto de coeficientes que lograron un error de aproximadamente 0.08 tanto en el tren como en el conjunto de datos de prueba.
El hecho de que el algoritmo haya encontrado un modelo con un rendimiento muy similar en los conjuntos de datos de prueba y tren es una buena señal, ya que muestra que el modelo no se ajustó en exceso (se optimizó en exceso) con el conjunto de datos de entrenamiento. Esto significa que el modelo se generaliza bien a nuevos datos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 dieciséis 17 |
… > 1546 0,35426 > 1567 0,32863 > 1572 0,32322 > 1619 0,24890 > 1665 0,24800 > 1691 0,24162 > 1715 0,15893 > 1809 0,15337 > 1892 0,14656 > 1956 0,08042 ¡Hecho! Coefficients:[130559829e-02-258299382e-04 333118191e+00 320418534e-02[130559829e-02-258299382e-04 333118191e+00 320418534e-02 1.36497902e-01 8.65445367e+01 2.78356715e-02 -8.50901499e-02 8.90078243e-02 6.15779867e-02 -3.85657793e-02] Train MSE: 0.080415 Test MSE: 0.080779 |
Now that we are familiar with how to manually optimize the coefficients of a linear regression model, let’s look at how we can extend the example to optimize the coefficients of a logistic regression model for classification.
Optimize a Logistic Regression Model
A Logistic Regression model is an extension of linear regression for classification predictive modeling.
Logistic regression is for binary classification tasks, meaning datasets that have two class labels, class=0 and class=1.
The output first involves calculating the weighted sum of the inputs, then passing this weighted sum through a logistic function, also called a sigmoid function. The result is a Binomial probability between 0 and 1 for the example belonging to class=1.
In this section, we will build on what we learned in the previous section to optimize the coefficients of regression models for classification. We will develop the model and test it with random coefficients, then use stochastic hill climbing to optimize the model coefficients.
First, let’s define a synthetic binary classification problem that we can use as the focus of optimizing the model.
We can use the make_classification() function to define a binary classification problem with 1,000 rows and five input variables.
The example below creates the dataset and summarizes the shape of the data.
|
# define a binary classification dataset de sklearn.datasets import make_classification # define dataset X, y = make_classification(n_samples=1000, n_features=5, n_informative=2, n_redundant=1, random_state=1) # summarize the shape of the dataset print(X.shape, y.shape) |
Running the example prints the shape of the created dataset, confirming our expectations.
Next, we need to define a logistic regression model.
Let’s start by updating the predict_row() function to pass the weighted sum of the input and coefficients through a logistic function.
The logistic function is defined as:
- logistic = 1.0 / (1.0 + exp(-result))
Where result is the weighted sum of the inputs and the coefficients and exp() is mi (Euler’s number) raised to the power of the provided value, implemented via the exp() function.
The updated predict_row() function is listed below.
|
# logistic regression def predict_row(row, coefficients): # add the bias, the last coefficient result = coefficients[[–1] # add the weighted input para i en range(len(row)): result += coefficients[[i] * row[[i] # logistic function logistic = 1.0 / (1.0 + exp(–result)) return logistic |
That’s about it in terms of changes for linear regression to logistic regression.
As with linear regression, we can test the model with a set of random model coefficients.
|
... # determine the number of coefficients n_coeff = X.shape[[1] + 1 # generate random coefficients coefficients = rand(n_coeff) # generate predictions for dataset yhat = predict_dataset(X, coefficients) |
The predictions made by the model are probabilities for an example belonging to class=1.
We can round the prediction to be integer values 0 and 1 for the expected class labels.
|
... # round predictions to labels yhat = [[round(y) para y en yhat] |
We can evaluate the classification accuracy of these predictions.
|
... # calculate accuracy score = accuracy_score(y, yhat) print(‘Accuracy: %f’ % score) |
Eso es todo.
We can tie all of this together and demonstrate our simple logistic regression model for binary classification. The complete example is listed below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 dieciséis 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
# logistic regression function for binary classification de math import exp de numpy.random import rand de sklearn.datasets import make_classification de sklearn.metrics import accuracy_score # logistic regression def predict_row(row, coefficients): # add the bias, the last coefficient result = coefficients[[–1] # add the weighted input para i en range(len(row)): result += coefficients[[i] * row[[i] # logistic function logistic = 1.0 / (1.0 + exp(–result)) return logistic # use model coefficients to generate predictions for a dataset of rows def predict_dataset(X, coefficients): yhats = list() para row en X: # make a prediction yhat = predict_row(row, coefficients) # store the prediction yhats.append(yhat) return yhats # define dataset X, y = make_classification(n_samples=1000, n_features=5, n_informative=2, n_redundant=1, random_state=1) # determine the number of coefficients n_coeff = X.shape[[1] + 1 # generate random coefficients coefficients = rand(n_coeff) # generate predictions for dataset yhat = predict_dataset(X, coefficients) # round predictions to labels yhat = [[round(y) para y en yhat] # calculate accuracy score = accuracy_score(y, yhat) print(‘Accuracy: %f’ % score) |
Running the example generates a prediction for each example in the training dataset then prints the classification accuracy for the predictions.
Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.
We would expect about 50 percent accuracy given a set of random weights and a dataset with an equal number of examples in each class, and that is approximately what we see in this case.
We can now optimize the weights of the dataset to achieve good accuracy on this dataset.
The stochastic hill climbing algorithm used for linear regression can be used again for logistic regression.
The important difference is an update to the objective() function to round the predictions and evaluate the model using classification accuracy instead of mean squared error.
|
# objective function def objective(X, y, coefficients): # generate predictions for dataset yhat = predict_dataset(X, coefficients) # round predictions to labels yhat = [[round(y) para y en yhat] # calculate accuracy score = accuracy_score(y, yhat) return score |
The hillclimbing() function also must be updated to maximize the score of solutions instead of minimizing in the case of linear regression.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 dieciséis 17 |
# hill climbing local search algorithm def hillclimbing(X, y, objective, solution, n_iter, step_size): # evaluate the initial point solution_eval = objective(X, y, solution) # run the hill climb para i en range(n_iter): # take a step candidate = solution + randn(len(solution)) * step_Talla # evaluate candidate point candidte_eval = objective(X, y, candidate) # check if we should keep the new point if candidte_eval >= solution_eval: # store the new point solution, solution_eval = candidate, candidte_eval # report progress print(‘>%d %.5f’ % (i, solution_eval)) return [[solution, solution_eval] |
Finally, the coefficients found by the search can be evaluated using classification accuracy at the end of the run.
|
... # generate predictions for the test dataset yhat = predict_dataset(X_test, coefficients) # round predictions to labels yhat = [[round(y) para y en yhat] # calculate accuracy score = accuracy_score(y_test, yhat) print(‘Test Accuracy: %f’ % (score)) |
Tying this all together, the complete example of using stochastic hill climbing to maximize classification accuracy of a logistic regression model is listed below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 dieciséis 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 sesenta y cinco 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 |
# optimize logistic regression model with a stochastic hill climber de math import exp de numpy.random import randn de numpy.random import rand de sklearn.datasets import make_classification de sklearn.model_selection import train_test_split de sklearn.metrics import accuracy_score # logistic regression def predict_row(row, coefficients): # add the bias, the last coefficient result = coefficients[[–1] # add the weighted input para i en range(len(row)): result += coefficients[[i] * row[[i] # logistic function logistic = 1.0 / (1.0 + exp(–result)) return logistic # use model coefficients to generate predictions for a dataset of rows def predict_dataset(X, coefficients): yhats = list() para row en X: # make a prediction yhat = predict_row(row, coefficients) # store the prediction yhats.append(yhat) return yhats # objective function def objective(X, y, coefficients): # generate predictions for dataset yhat = predict_dataset(X, coefficients) # round predictions to labels yhat = [[round(y) para y en yhat] # calculate accuracy score = accuracy_score(y, yhat) return score # hill climbing local search algorithm def hillclimbing(X, y, objective, solution, n_iter, step_size): # evaluate the initial point solution_eval = objective(X, y, solution) # run the hill climb para i en range(n_iter): # take a step candidate = solution + randn(len(solution)) * step_Talla # evaluate candidate point candidte_eval = objective(X, y, candidate) # check if we should keep the new point if candidte_eval >= solution_eval: # store the new point solution, solution_eval = candidate, candidte_eval # report progress print(‘>%d %.5f’ % (i, solution_eval)) return [[solution, solution_eval] # define dataset X, y = make_classification(n_samples=1000, n_features=5, n_informative=2, n_redundant=1, random_state=1) # split into train test sets X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33) # define the total iterations n_iter = 2000 # define the maximum step size step_size = 0.1 # determine the number of coefficients n_coef = X.shape[[1] + 1 # define the initial solution solution = rand(n_coef) # perform the hill climbing search coefficients, score = hillclimbing(X_train, y_train, objective, solution, n_iter, step_size) print(‘Done!’) print(‘Coefficients: %s’ % coefficients) print(‘Train Accuracy: %f’ % (score)) # generate predictions for the test dataset yhat = predict_dataset(X_test, coefficients) # round predictions to labels yhat = [[round(y) para y en yhat] # calculate accuracy score = accuracy_score(y_test, yhat) print(‘Test Accuracy: %f’ % (score)) |
Running the example will report the iteration number and classification accuracy each time there is an improvement made to the model.
At the end of the search, the performance of the best set of coefficients on the training dataset is reported and the performance of the same model on the test dataset is calculated and reported.
Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.
In this case, we can see that the optimization algorithm found a set of weights that achieved about 87.3 percent accuracy on the training dataset and about 83.9 percent accuracy on the test dataset.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 dieciséis 17 18 19 20 |
… >200 0.85672 >225 0.85672 >230 0.85672 >245 0.86418 >281 0.86418 >285 0.86716 >294 0.86716 >306 0.86716 >316 0.86716 >317 0.86716 >320 0.86866 >348 0.86866 >362 0.87313 >784 0.87313 >1649 0.87313 Done! Coefficients: [-0.04652756 0.23243427 2.58587637 -0.45528253 -0.4954355 -0.42658053] Train Accuracy: 0.873134 Test Accuracy: 0.839394 |
Further Reading
This section provides more resources on the topic if you are looking to go deeper.
APIs
Articles
Resumen
In this tutorial, you discovered how to manually optimize the coefficients of regression models.
Specifically, you learned:
- How to develop the inference models for regression from scratch.
- How to optimize the coefficients of a linear regression model for predicting numeric values.
- How to optimize the coefficients of a logistic regression model using stochastic hill climbing.
Do you have any questions?
Ask your questions in the comments below and I will do my best to answer.