一、Python
import random
import numpy as np
import matplotlib.pyplot as plt
# 定义激活函数
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# 定义激活函数的导数
def sigmoid_derivative(x):
sig = sigmoid(x)
return sig * (1 - sig)
# 定义预测函数
def predict(x, w, b):
return x * w + b
# 定义训练函数
def train(x, y, w, b, learning_rate, epochs):
n = x.shape[0]
for i in range(epochs):
random_index = random.randint(0, n-1)
input_val = x[random_index]
target_val = y[random_index]
# 前向传播
output_val = predict(input_val, w, b)
# 反向传播
output_error = target_val - output_val
output_delta = output_error
# 更新权重和偏置
w += learning_rate * output_delta * input_val
b += learning_rate * output_delta
return w, b
# 定义生成数据函数
def generate_data(true_w, true_b, num_examples, x_range):
x = np.random.uniform(-x_range, x_range, size=num_examples)
noise = np.random.normal(scale=0.1, size=num_examples)
y = true_w * x + true_b + noise
return x, y
# 定义真实的权重和偏置
true_w = 2
true_b = 4.2
x_range = 10
# 生成数据
num_examples = 1000
x, y = generate_data(true_w, true_b, num_examples, x_range)
# 初始化权重和偏置
w = 0
b = 0
# 设置学习率和迭代次数
learning_rate = 0.01
epochs = 1000
# 训练模型
w, b = train(x, y, w, b, learning_rate, epochs)
# 输出模型权重和偏置
print("Model weights: w={}, b={}".format(w, b))
# 预测新数据
x_pred = np.array([6, 7, 8, 9, 10])
y_pred = predict(x_pred, w, b)
# 输出预测结果
print("Input values: {}".format(x_pred))
print("Predicted values: {}".format(y_pred))
# 绘制数据和模型预测
plt.scatter(x, y, s=0.1)
plt.plot(x_pred, y_pred, color='red')
plt.xlabel('x')
plt.ylabel('y')
plt.show()
二、C++
#include <iostream>
#include <vector>
#include <random>
#include <cmath>
using namespace std;
// 定义激活函数
double sigmoid(double x) {
return 1 / (1 + exp(-x));
}
// 定义激活函数的导数
double sigmoid_derivative(double x) {
double sig = sigmoid(x);
return sig * (1 - sig);
}
// 定义预测函数
vector<double> predict(vector<double>& x, vector<double>& w, double b) {
vector<double> y_pred;
for (double input : x) {
double output = input * w[0] + b; // 计算输出层输出
y_pred.push_back(output); // 将输出添加到预测向量中
}
return y_pred;
}
// 定义训练函数
void train(vector<double>& x, vector<double>& y, vector<double>& w, double& b, double learning_rate, int epochs) {
int n = x.size();
default_random_engine generator;
uniform_int_distribution<int> distribution(0, n - 1);
for (int i = 0; i < epochs; i++) {
int random_index = distribution(generator);
double input = x[random_index];
double target = y[random_index];
// 前向传播
double output = input * w[0] + b; // 计算输出层输出
// 反向传播
double output_error = target - output; // 计算输出层误差
double output_delta = output_error; // 计算输出层误差项
// 更新权重和偏置
w[0] += learning_rate * output_delta * input;
b += learning_rate * output_delta;
}
}
// 定义生成数据函数
void generate_data(double w, double b, int num_examples, vector<double>& x, vector<double>& y, double x_range) {
// w: 真实权重
// b: 真实偏置
// num_examples: 样本数量
// x: 特征向量
// y: 标签向量
// x_range: 特征范围
default_random_engine generator; // 定义随机数生成器
uniform_real_distribution<double> distribution(-x_range, x_range); // 定义均匀分布
for (int i = 0; i < num_examples; i++) { // 生成数据
double feature = distribution(generator); // 生成特征
x.push_back(feature);
double dot_product = w * feature; // 计算点积
y.push_back(dot_product + b + distribution(generator)); // 添加噪声
}
}
int main() {
// 定义真实的权重和偏置
double true_w = 2;
double true_b = 4.2;
double x_range=2;
// 生成数据
vector<double> x;
vector<double> y;
int num_examples = 1000;
generate_data(true_w, true_b, num_examples, x, y,x_range);
// 初始化权重和偏置
vector<double> w = {0};
double b = 0;
// 设置学习率和迭代次数
double learning_rate = 0.01;
int epochs = 1000;
// 训练模型
train(x, y, w, b, learning_rate, epochs);
// 输出模型权重和偏置
cout << "Model weights: w=" << w[0] << ", b=" << b << endl;
// 预测新数据
vector<double> x_pred = {6, 7, 8, 9, 10};
vector<double> y_pred = predict(x_pred, w, b);
// 输出预测结果
cout << "Input values: ";
for (double x_val : x_pred) {
cout << x_val << " ";
}
cout << endl;
cout << "Predicted values: ";
for (double y_val : y_pred) {
cout << y_val << " ";
}
cout << endl;
return 0;
}