Visualización de la función de pérdida

Para $Para\; m$ muestras, utilice MSE como función de pérdida.

Si la muestra tiene un solo atributo $X_{yo}$, Entonces la función de pérdida es:
$$L=\frac{1}{metro}\underset{yo}{\Sigma }(w\ast X_{yo}+y_{yo}{)}^2$$
Dibujemos la imagen de la función de pérdida:

import numpy as np
import matplotlib.pyplot as plt

def image(b=0):
    dense = 400
    w = np.linspace(-2,4,dense)
    x_train = np.array([0,   1,	  2,   3,   4,   5])
    y_train = np.array([1.1, 2.2,  3.8, 4.1, 4.9, 5.2])


    for i in range(dense):
        loss = np.square(w[i] * x_train+b - y_train).sum() / len(x_train)
        plt.scatter(w[i],loss,s=1)

    plt.title('Loss Func Line')
    plt.xlabel('w')
    plt.ylabel('loss')
    plt.axis([0,3,0,10])
    plt.axhline(y=1, ls=":", c="black")
    plt.axhline(y=2, ls=":", c="black")
    plt.axhline(y=4, ls=":", c="black")
    plt.axhline(y=7, ls=":", c="black")
    plt.show()

image()

Figura 1

En la Figura 1, el desplazamiento $ b = 0 $, paralelo al eje $ x $ es el contorno de la función de pérdida. Más sesgo:

imagen (0.5)	imagen (1)
imagen (1.7)	imagen (2.5)

Puedes ver el sesgo bbEl cambio de$b$ afecta directamente el valor mínimo de la función de pérdida y la correspondiente$w$。

Arriba estamos arreglando $b$ imagenwwLos dividendos de$wy$ loss. Ahora dibujamos el pesoww encoordenadas 3D$w$ y sesgo$b$ pérdida correspondiente:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D  # Axes3D 包含的是实现3d绘图的各种方法


x_train = np.array([0,   1,	  2,   3,   4,   5])
y_train = np.array([1.1, 2.2,  3.8, 4.1, 4.9, 5.2])

dense = 400
w,b = np.meshgrid(np.linspace(-2,4, dense),np.linspace(-7,10, dense))

# y = wx+b
def get_loss_value(w,b):
    return np.square(w*x_train+b - y_train).sum()/len(x_train)

def loss_point():
    loss_list = []
    for i in range(dense):
        loss_list2=[]
        for j in range(dense):
            loss = get_loss_value(w[i][j], b[i][j])
            loss_list2.append(loss)
        loss_list.append(loss_list2)
    return loss_list



fig = plt.figure()
ax = Axes3D(fig)
loss = np.array(loss_point())

# 添加坐标轴(顺序是Z, Y, X)
ax.set_xlabel('w')
ax.set_ylabel('b')
ax.set_zlabel('L')
ax.plot_surface(w, b, loss, rstride=30,cstride=30, cmap='jet')
plt.show()

Figura 2

Un total de 400 * 400 = 160000 valores de pérdida se calculan arriba, entonces, ¿cuál de estos muchos valores de pérdida es el mismo? ¿Cómo se ve cuando dibujamos tal punto en un espacio bidimensional compuesto por $ w $ y $ b $?

import numpy as np
import matplotlib.pyplot as plt

x_train = np.array([0,   1,	  2,   3,   4,   5])
y_train = np.array([1.1, 2.2,  3.8, 4.1, 4.9, 5.2])

dense = 400

# y = wx+b
def get_loss_value(w,b):
    return np.square(w*x_train+b - y_train).sum()/len(x_train)


w = np.linspace(-2,4,dense)
b = np.linspace(-7,10,dense)

def draw_contour_line(dense,isoheight): #dense表示取值的密度，isoheight表示等高线的值
    list_w = []
    list_b = []
    list_loss = []
    for i in range(dense):
        for j in range(dense):
            loss = get_loss_value(w[i],b[j])
            if 1.05*isoheight>loss>0.95*isoheight:
                list_w.append(w[i])
                list_b.append(b[j])
            else:
                pass
    plt.scatter(list_w,list_b,s=1) #s=0.25比较合适

draw_contour_line(dense,1)
draw_contour_line(dense,4)
draw_contour_line(dense,7)
draw_contour_line(dense,10)
draw_contour_line(dense,20)
draw_contour_line(dense,30)
draw_contour_line(dense,50)
draw_contour_line(dense,100)
draw_contour_line(dense,200)
plt.title('Loss Func Contour Line')
plt.xlabel('w')
plt.ylabel('b')
plt.axis([-2,4,-7,10])
plt.show()

Figura 3: Contornos de pérdida en el espacio de parámetros

La figura 3 es la misma que esperábamos. La figura 3 es como usar un wob wob paralelo a la figura 2$El$ plano$w$$o$$b$ es un plano tangente a lo largo del eje L, y los puntos tocados por el plano tangente tienen la misma pérdida. También se puede ver en la Figura 2 que cuando la pérdida es menor a 20, puede aparecer un contorno elíptico, y cuando la pérdida es grande, no es elíptica.

Así que a menudo vemos esta imagen cuando aprendemos el algoritmo de descenso de gradiente:

esta imagen suele ir seguida de una oración,la dirección del descenso de gradiente es perpendicular a la dirección de la tangente de la línea de contorno.

Se puede ver que el cambio del punto en el espacio de parámetros es equivalente al "cuesta arriba" o "cuesta abajo" de la función de pérdida.

Artículo de referencia:
https://blog.csdn.net/keeppractice/article/details/105620966
Entender que la dirección del gradiente es perpendicular a la dirección del contorno