Beispiel für die Implementierung des Deming-Regressionsalgorithmus mit TensorFlow

Dieser Artikel stellt hauptsächlich Beispiele für die Verwendung von TensorFlow zur Implementierung des Deming-Regressionsalgorithmus vor. Er hat einen bestimmten Referenzwert. Jetzt können Freunde in Not darauf zurückgreifen.

Wenn die kleinste Quadrate lineare Regression ist Der Algorithmus minimiert den vertikalen Abstand zur Regressionslinie (d. h. parallel zur y-Achsenrichtung), dann minimiert die Deming-Regression den Gesamtabstand zur Regressionslinie (d. h. senkrecht zur Regressionslinie). Es minimiert den Fehler in beiden Richtungen des X-Werts und des Y-Werts. Die spezifische Vergleichstabelle sieht wie folgt aus.

Der Unterschied zwischen dem linearen Regressionsalgorithmus und dem Deming-Regressionsalgorithmus. Die lineare Regression auf der linken Seite minimiert den vertikalen Abstand zur Regressionsgeraden; die Deming-Regression auf der rechten Seite minimiert den Gesamtabstand zur Regressionsgeraden.

Die Verlustfunktion des linearen Regressionsalgorithmus minimiert den vertikalen Abstand; hier ist es notwendig, den Gesamtabstand zu minimieren. Angesichts der Steigung und des Achsenabschnitts einer geraden Linie gibt es eine bekannte geometrische Formel zur Lösung des vertikalen Abstands von einem Punkt zur geraden Linie. Setzen Sie die geometrische Formel ein und lassen Sie TensorFlow den Abstand minimieren.

Die Verlustfunktion ist eine geometrische Formel, die aus einem Zähler und einem Nenner besteht. Bei einer gegebenen geraden Linie y=mx+b und einem Punkt (x0, y0) lautet die Formel zum Ermitteln des Abstands zwischen den beiden:

# 戴明回归
#----------------------------------
#
# This function shows how to use TensorFlow to
# solve linear Deming regression.
# y = Ax + b
#
# We will use the iris data, specifically:
# y = Sepal Length
# x = Petal Width

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from sklearn import datasets
from tensorflow.python.framework import ops
ops.reset_default_graph()

# Create graph
sess = tf.Session()

# Load the 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])

# 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)

# 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)

# Declare Demming loss function
demming_numerator = tf.abs(tf.subtract(y_target, tf.add(tf.matmul(x_data, A), b)))
demming_denominator = tf.sqrt(tf.add(tf.square(A),1))
loss = tf.reduce_mean(tf.truep(demming_numerator, demming_denominator))

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

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

# Training loop
loss_vec = []
for i in range(250):
  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)
  if (i+1)%50==0:
    print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)) + ' b = ' + str(sess.run(b)))
    print('Loss = ' + str(temp_loss))

# 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 the result
plt.plot(x_vals, y_vals, 'o', label='Data Points')
plt.plot(x_vals, best_fit, 'r-', label='Best fit line', linewidth=3)
plt.legend(loc='upper left')
plt.title('Sepal Length vs Pedal Width')
plt.xlabel('Pedal Width')
plt.ylabel('Sepal Length')
plt.show()

# Plot loss over time
plt.plot(loss_vec, 'k-')
plt.title('L2 Loss per Generation')
plt.xlabel('Generation')
plt.ylabel('L2 Loss')
plt.show()

Ergebnisse:

Die mit dem Deming-Regressionsalgorithmus und der linearen Regression erhaltenen Ergebnisse Algorithmus in diesem Artikel Im Grunde das Gleiche. Der Hauptunterschied zwischen den beiden ist die Messung der Verlustfunktion zwischen dem vorhergesagten Wert und dem Datenpunkt: Die Verlustfunktion des linearen Regressionsalgorithmus ist der vertikale Distanzverlust, während der Deming-Regressionsalgorithmus der vertikale Distanzverlust ist (Gesamtwert). x-Achse und y-Achse Distanzverlust).

Beachten Sie, dass der Implementierungstyp des Deming-Regressionsalgorithmus hier die Gesamtregression ist (gesamter Fehler der kleinsten Quadrate). Der allgemeine Regressionsalgorithmus geht davon aus, dass die Fehler in den x- und y-Werten ähnlich sind. Wir können auch unterschiedliche Fehler verwenden, um die Abstandsberechnung der x-Achse und der y-Achse nach unterschiedlichen Konzepten zu erweitern.

Verwandte Empfehlungen:

Beispielcode für die Implementierung von Multi-Class-Support-Vektor-Maschinen mit TensorFlow

TensorFlow implementiert nichtlineare Support-Vektor-Maschinen-Methode

Das obige ist der detaillierte Inhalt vonBeispiel für die Implementierung des Deming-Regressionsalgorithmus mit TensorFlow. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!