Beispiele für die Implementierung von Lasso-Regressions- und Ridge-Regressionsalgorithmen mit TensorFlow

Dieser Artikel stellt hauptsächlich Beispiele für die Verwendung von Lasso-Regressions- und Ridge-Regressionsalgorithmen vor. Jetzt kann ich ihn mit Ihnen teilen.

Es gibt auch Einige reguläre Methoden können den Einfluss von Koeffizienten auf die Ausgabeergebnisse von Regressionsalgorithmen begrenzen. Die beiden am häufigsten verwendeten Regularisierungsmethoden sind Lasso-Regression und Ridge-Regression.

Die Lasso-Regressions- und Ridge-Regressions-Algorithmen sind dem herkömmlichen linearen Regressionsalgorithmus sehr ähnlich. Der einzige Unterschied besteht darin, dass der Formel ein regulärer Term hinzugefügt wird, um die Steigung (oder Nettosteigung) zu begrenzen. Der Hauptgrund dafür besteht darin, den Einfluss des Merkmals auf die abhängige Variable zu begrenzen, was durch Hinzufügen einer Verlustfunktion erreicht wird, die von der Steigung A abhängt.

Fügen Sie für den Lasso-Regressionsalgorithmus ein Element zur Verlustfunktion hinzu: ein gegebenes Vielfaches der Steigung A. Wir verwenden die logischen Operationen von TensorFlow, jedoch ohne die mit diesen Operationen verbundenen Verläufe. Stattdessen verwenden wir eine kontinuierliche Schätzung einer Schrittfunktion, auch kontinuierliche Schrittfunktion genannt, die an einem Grenzpunkt springt und sich ausdehnt. Sie werden gleich sehen, wie Sie den Lasso-Regressionsalgorithmus verwenden.

Fügen Sie für den Ridge-Regressionsalgorithmus eine L2-Norm hinzu, bei der es sich um die L2-Regularisierung des Steigungskoeffizienten handelt.

# LASSO and Ridge Regression
# lasso回归和岭回归
# 
# This function shows how to use TensorFlow to solve LASSO or 
# Ridge regression for 
# y = Ax + b
# 
# We will use the iris data, specifically: 
#  y = Sepal Length 
#  x = Petal Width

# import required libraries
import matplotlib.pyplot as plt
import sys
import numpy as np
import tensorflow as tf
from sklearn import datasets
from tensorflow.python.framework import ops


# Specify 'Ridge' or 'LASSO'
regression_type = 'LASSO'

# clear out old graph
ops.reset_default_graph()

# Create graph
sess = tf.Session()

###
# Load iris data
###

# iris.data = [(Sepal Length, Sepal Width, Petal Length, Petal Width)]
iris = datasets.load_iris()
x_vals = np.array([x[3] for x in iris.data])
y_vals = np.array([y[0] for y in iris.data])

###
# Model Parameters
###

# Declare batch size
batch_size = 50

# Initialize placeholders
x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

# make results reproducible
seed = 13
np.random.seed(seed)
tf.set_random_seed(seed)

# Create variables for linear regression
A = tf.Variable(tf.random_normal(shape=[1,1]))
b = tf.Variable(tf.random_normal(shape=[1,1]))

# Declare model operations
model_output = tf.add(tf.matmul(x_data, A), b)

###
# Loss Functions
###

# Select appropriate loss function based on regression type

if regression_type == 'LASSO':
  # Declare Lasso loss function
  # 增加损失函数，其为改良过的连续阶跃函数，lasso回归的截止点设为0.9。
  # 这意味着限制斜率系数不超过0.9
  # Lasso Loss = L2_Loss + heavyside_step,
  # Where heavyside_step ~ 0 if A < constant, otherwise ~ 99
  lasso_param = tf.constant(0.9)
  heavyside_step = tf.truep(1., tf.add(1., tf.exp(tf.multiply(-50., tf.subtract(A, lasso_param)))))
  regularization_param = tf.multiply(heavyside_step, 99.)
  loss = tf.add(tf.reduce_mean(tf.square(y_target - model_output)), regularization_param)

elif regression_type == &#39;Ridge&#39;:
  # Declare the Ridge loss function
  # Ridge loss = L2_loss + L2 norm of slope
  ridge_param = tf.constant(1.)
  ridge_loss = tf.reduce_mean(tf.square(A))
  loss = tf.expand_dims(tf.add(tf.reduce_mean(tf.square(y_target - model_output)), tf.multiply(ridge_param, ridge_loss)), 0)

else:
  print(&#39;Invalid regression_type parameter value&#39;,file=sys.stderr)


###
# Optimizer
###

# Declare optimizer
my_opt = tf.train.GradientDescentOptimizer(0.001)
train_step = my_opt.minimize(loss)

###
# Run regression
###

# Initialize variables
init = tf.global_variables_initializer()
sess.run(init)

# Training loop
loss_vec = []
for i in range(1500):
  rand_index = np.random.choice(len(x_vals), size=batch_size)
  rand_x = np.transpose([x_vals[rand_index]])
  rand_y = np.transpose([y_vals[rand_index]])
  sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})
  temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y})
  loss_vec.append(temp_loss[0])
  if (i+1)%300==0:
    print(&#39;Step #&#39; + str(i+1) + &#39; A = &#39; + str(sess.run(A)) + &#39; b = &#39; + str(sess.run(b)))
    print(&#39;Loss = &#39; + str(temp_loss))
    print(&#39;\n&#39;)

###
# Extract regression results
###

# Get the optimal coefficients
[slope] = sess.run(A)
[y_intercept] = sess.run(b)

# Get best fit line
best_fit = []
for i in x_vals:
 best_fit.append(slope*i+y_intercept)


###
# Plot results
###

# Plot regression line against data points
plt.plot(x_vals, y_vals, &#39;o&#39;, label=&#39;Data Points&#39;)
plt.plot(x_vals, best_fit, &#39;r-&#39;, label=&#39;Best fit line&#39;, linewidth=3)
plt.legend(loc=&#39;upper left&#39;)
plt.title(&#39;Sepal Length vs Pedal Width&#39;)
plt.xlabel(&#39;Pedal Width&#39;)
plt.ylabel(&#39;Sepal Length&#39;)
plt.show()

# Plot loss over time
plt.plot(loss_vec, &#39;k-&#39;)
plt.title(regression_type + &#39; Loss per Generation&#39;)
plt.xlabel(&#39;Generation&#39;)
plt.ylabel(&#39;Loss&#39;)
plt.show()

Ausgabeergebnis:

Schritt #300 A = [[ 0,77170753]] b = [[ 1,82499862]]
Verlust = [[ 10,26473045]]
Schritt #600 A = [[ 0,75908542]] b = [[ 3,2220633]]
Verlust = [[ 3,06292033]]
Schritt #900 A = [[ 0,74843585] ] b = [[ 3,9975822]]
Verlust = [[ 1,23220456]]
Schritt #1200 A = [[ 0,73752165]] b = [[ 4,42974091]]
Verlust = [[ 0,57872057]]
Schritt #1500 A = [[ 0,72942668]] b = [[ 4,67253113]]
Verlust = [[ 0,40874988]]

Der Lasso-Regressionsalgorithmus wird durch Hinzufügen einer kontinuierlichen Schrittfunktion basierend auf der standardmäßigen linearen Regressionsschätzung implementiert. Aufgrund der Steigung der Schrittfunktion müssen wir auf die Schrittgröße achten, da eine zu große Schrittgröße letztendlich zu Nichtkonvergenz führt.

Verwandte Empfehlungen:

Beispiel für die Verwendung von TensorFlow zur Implementierung des Deming-Regressionsalgorithmus

Das obige ist der detaillierte Inhalt vonBeispiele für die Implementierung von Lasso-Regressions- und Ridge-Regressionsalgorithmen mit TensorFlow. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!