梯度下降算法go语言

以下是一个简单的梯度下降算法的 Go 语言实现：

func gradientDescent(x []float64, y []float64, alpha float64, numIterations int) ([]float64, float64) {
    m := len(x) // 样本数量
    theta := []float64{0, 0} // 参数向量
    cost := 0.0

    for i := 0; i < numIterations; i++ {
        h := hypothesis(theta, x) // 假设函数
        loss := h - y // 误差
        gradient := []float64{0, 0}
        for j := 0; j < m; j++ {
            gradient[0] += loss[j]
            gradient[1] += loss[j] * x[j]
        }
        gradient[0] /= float64(m)
        gradient[1] /= float64(m)

        // 更新参数向量
        theta[0] -= alpha * gradient[0]
        theta[1] -= alpha * gradient[1]

        // 计算损失函数值
        cost = costFunction(theta, x, y)
    }

    return theta, cost
}

func hypothesis(theta []float64, x []float64) []float64 {
    m := len(x)
    h := make([]float64, m)
    for i := 0; i < m; i++ {
        h[i] = theta[0] + theta[1]*x[i]
    }
    return h
}

func costFunction(theta []float64, x []float64, y []float64) float64 {
    m := len(x)
    h := hypothesis(theta, x)
    sum := 0.0
    for i := 0; i < m; i++ {
        sum += (h[i] - y[i]) * (h[i] - y[i])
    }
    return sum / (2 * float64(m))
}

其中，`gradientDescent` 函数是梯度下降算法的主要实现，它接受输入数据 `x` 和 `y`，学习率 `alpha`，以及迭代次数 `numIterations`，并返回最终的参数向量和损失函数值。在每一次迭代中，它先计算出当前的假设函数 `h` 和误差 `loss`，然后按照公式更新参数向量 `theta`，最后计算出损失函数值 `cost`。

`hypothesis` 函数用于计算假设函数的值，它接受参数向量 `theta` 和输入数据 `x`，并返回假设函数的值。

`costFunction` 函数用于计算损失函数的值，它接受参数向量 `theta`、输入数据 `x` 和输出数据 `y`，并返回损失函数的值。

在使用梯度下降算法时，我们需要先定义一个合适的模型，然后选择合适的学习率和迭代次数，最后调用 `gradientDescent` 函数进行训练。