GradientDescentOptimizer结果错误

Question

我想使用梯度下降来解决方程组，但每次都得到错误的结果，所以我检查了我的代码并写了一个numpy版本，在这个版本中我提供了明确的损失梯度，我可以获得当前的结果。< /强>

所以我不明白为什么GradientDescentOptimizer无法工作。

这是我没有tf的代码：

import numpy as np


class SolveEquation:
    def __init__(self, rate: float, loss_threshold: float=0.0001, max_epochs: int=1000):
        self.__rate = rate
        self.__loss_threshold = loss_threshold
        self.__max_epochs = max_epochs
        self.__x = None

    def solve(self, coefficients, b):
        _a = np.array(coefficients)
        _b = np.array(b).reshape([len(b), 1])
        _x = np.zeros([_a.shape[1], 1])
        for epoch in range(self.__max_epochs):
            grad_loss = np.matmul(np.transpose(_a), np.matmul(_a, _x) - _b)
            _x -= self.__rate * grad_loss
            if epoch % 10 == 0:
                loss = np.mean(np.square(np.subtract(np.matmul(_a, _x), _b)))
                print('loss = {:.8f}'.format(loss))
                if loss < self.__loss_threshold:
                    break
        return _x

s = SolveEquation(0.1, max_epochs=1)
print(s.solve([[1, 2], [1, 3]], [3, 4]))

以下是我的代码：tf：

import tensorflow as tf
import numpy as np


class TFSolveEquation:
    def __init__(self, rate: float, loss_threshold: float=0.0001, max_epochs: int=1000):
        self.__rate = rate
        self.__loss_threshold = tf.constant(loss_threshold)
        self.__max_epochs = max_epochs
        self.__session = tf.Session()
        self.__x = None

    def __del__(self):
        try:
            self.__session.close()
        finally:
            pass

    def solve(self, coefficients, b):
        coefficients_data = np.array(coefficients)
        b_data = np.array(b)
        _a = tf.placeholder(tf.float32)
        _b = tf.placeholder(tf.float32)
        _x = tf.Variable(tf.zeros([coefficients_data.shape[1], 1]))
        loss = tf.reduce_mean(tf.square(tf.matmul(_a, _x) - _b))
        optimizer = tf.train.GradientDescentOptimizer(self.__rate)
        model = optimizer.minimize(loss)
        self.__session.run(tf.global_variables_initializer())
        for epoch in range(self.__max_epochs):
            self.__session.run(model, {_a: coefficients_data, _b: b_data})
            if epoch % 10 == 0:
                if self.__session.run(loss < self.__loss_threshold, {_a: coefficients_data, _b: b_data}):
                    break
        return self.__session.run(_x)

s = TFSolveEquation(0.1, max_epochs=1)
print(s.solve([[1, 2], [1, 3]], [3, 4]))

我用非常简单的方程组测试这两个代码：

x_1 + 2 * x_2 = 3
x_1 + 3 * x_3 = 4

loss = 1/2 * || Ax - b ||^2

Init x_1 = 0, x_2 = 0, rate = 0.1

使用渐变下降 因此，在第一次计算时，delta x =（0.7,1.8）

但不幸的是我的代码用tf给出了

delta x = 
[[ 0.69999999]
 [ 1.75      ]]

我的代码没有提供

delta x = 
[[ 0.7]
 [ 1.8]]

没有tf的绝对代码是正确的，但为什么tf计算梯度可能会小于0.05然后是当前结果？ 我认为这是我没有tf的代码可以解决方程组的原因，但是tf版本目前无法解决方程组。

有人可以告诉我为什么要给出一个渐变的渐变？感谢

我的平台是Win10 + tensorflow-gpu v1.0

Answer 1

您忘记在张量流实施中重塑_b。因此，您要从此行的列中减去一行：loss = tf.reduce_mean(tf.square(tf.matmul(_a, _x) - _b))。

编辑：在不指定缩减轴的情况下，不要使用缩减操作（例如均值或求和）。默认情况下，numpy和tensorflow中的缩减操作会沿着所有维度减少，因此无论输入数组的大小如何，您都会获得单个数字。这可能导致许多模糊不清的错误。