import random

# 学习率
rate = 0.01

# XOR 门测试数据
x = [[0, 0], [0, 1], [1, 0], [1, 1]]
y = [0, 1, 1, 0]

w1 = random.random()
w2 = random.random()
w3 = random.random()
w4 = random.random()
w5 = random.random()
w6 = random.random()
b1 = random.random()
b2 = random.random()
b3 = random.random()


# relu 激活函数
def relu(v):
    if v < 0:
        return 0
    else:
        return v

# 函数的定义
def h1(x1, x2):
    return w1 * x1 + w3 * x2 + b1

def h2(x1, x2):
    return w2 * x1 + w4 * x2 + b2

def h3(y1, y2):
    return w5 * y1 + w6 * y2 + b3


def y1(h1):
    return relu(h1)

def y2(h2):
    return relu(h2)

print("初始化的权重和偏置: ")
print(w1, w2, w3, w4, w5, w6, b1, b2, b3)

# 训练迭代
epoch = 10000
while epoch > 0:
    epoch = epoch - 1;
    
     # w 和 b 更新算法
    dw1 = dw2 = dw3 = dw4 = dw5 = dw6 = 0.0
    db1 = db2 = db3 = 0.0

    # 遍历测试数据集
    for xs, yhat in zip(x, y):
        [x1, x2] = xs

        # 预测值
        # 为区分函数和数值，所以新增 v 后缀
        h1_v = h1(x1, x2)
        h2_v = h2(x1, x2)
        y1_v = relu(h1_v)
        y2_v = relu(h2_v)
        h3_v = h3(y1_v, y2_v)
        y_v = relu(h3_v)

        # w5 和 w6 更新
        if h3_v > 0:
            dw5 += 2 * (y_v - yhat) * y1_v
            dw6 += 2 * (y_v - yhat) * y2_v
            db3 += 2 * (y_v - yhat) * 1

            if h1_v > 0:
                dw1 += 2 * (y_v - yhat) * w5 * x1
                dw3 += 2 * (y_v - yhat) * w5 * x2
                db1 += 2 * (y_v - yhat) * w5
            if h2_v > 0:
                dw2 += 2 * (y_v - yhat) * w6 * x1
                dw4 += 2 * (y_v - yhat) * w6 * x2
                db2 += 2 * (y_v - yhat) * w6


    dw1 = dw1 / len(x)
    dw2 = dw2 / len(x)
    dw3 = dw3 / len(x)
    dw4 = dw4 / len(x)
    dw5 = dw5 / len(x)
    dw6 = dw6 / len(x)
    db1 = db1 / len(x)
    db2 = db2 / len(x)
    db3 = db3 / len(x)

    # 更新
    w1 = w1 - rate * dw1
    w2 = w2 - rate * dw2
    w3 = w3 - rate * dw3
    w4 = w4 - rate * dw4
    w5 = w5 - rate * dw5
    w6 = w6 - rate * dw6
    b1 = b1 - rate * db1
    b2 = b2 - rate * db2
    b3 = b3 - rate * db3

print("训练后的权重和偏置: ")
print(w1, w2, w3, w4, w5, w6, b1, b2, b3)


def forword(x1, x2):
    h1_v = h1(x1, x2)
    h2_v = h2(x1, x2)
    y1_v = relu(h1_v)
    y2_v = relu(h2_v)
    h3_v = h3(y1_v, y2_v)
    y_v = relu(h3_v)
    print(f"x1 {x1}, x2 {x2} => y1 {y1_v}, y2 {y2_v} => y {y_v}")
    return y_v

print("预测结果:")
forword(0, 0)
forword(0, 1)
forword(1, 0)
forword(1, 1)

import torch
import torch.nn as nn

# 测试数据
x = torch.tensor([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
y = torch.tensor([[0.0], [1.0], [1.0], [0.0]])

# 创建预测模型，包含一个输入层（2个参数）、一个隐藏层（2个神经元）、一个输出，并在每个输出层添加一个 ReLU 激活函数
model = nn.Sequential(nn.Linear(2, 2), nn.ReLU(), nn.Linear(2, 1), nn.ReLU())

# 定义均方误差损失函数
mseloss = torch.nn.MSELoss()
# 随机梯度下降优化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)  # 学习率为0.1， learning rate

# 执行梯度下降算法进行模型训练
for epoch in range(10000):
    y_pred = model(x)  # 计算预测值
    loss = mseloss(y_pred, y)  # 计算损失
    
    optimizer.zero_grad()  # 清零梯度
    loss.backward()  # 反向传播，计算梯度
    optimizer.step()  # 更新模型参数

# 预测
print(model.forward(torch.tensor([0.0, 0.0])))
print(model.forward(torch.tensor([0.0, 1.0])))
print(model.forward(torch.tensor([1.0, 0.0])))
print(model.forward(torch.tensor([1.0, 1.0])))