wolves/AI-learning
1
0
Fork 0
Code Releases Activity

241005

Browse Source
This commit is contained in:
Wolves
2024-10-05 23:05:49 +08:00
parent 804b63b2a3
commit 150cd78949
6 changed files with 296 additions and 337 deletions
Download Patch File Download Diff File Expand all files Collapse all files

338
linear regression/1.py
View File

@@ -1,56 +1,310 @@
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from matplotlib import pyplot as plt
def compute_error_for_line_given_points(b, w, points):
totalError = 0
N = float(len(points))
for i in range(len(points)):
x = points[i][0]
y = points[i][1]
totalError += (y - (w * x + b)) ** 2
return totalError / N
def run1():
def compute_error_for_line_given_points(b, w, points):
totalError = 0
N = float(len(points))
for i in range(len(points)):
x = points[i][0]
y = points[i][1]
totalError += (y - (w * x + b)) ** 2
return totalError / N
def step_gradient(b_current, w_current, points, learningRate):
b_gradient = torch.tensor(0.0, device=points.device, dtype=torch.float32)
w_gradient = torch.tensor(0.0, device=points.device, dtype=torch.float32)
N = float(len(points))
for i in range(len(points)):
x = points[i][0]
y = points[i][1]
b_gradient += -(2 / N) * (y - (w_current * x + b_current))
w_gradient += -(2 / N) * x * (y - (w_current * x + b_current))
new_b = b_current - (learningRate * b_gradient)
new_w = w_current - (learningRate * w_gradient)
return [new_b, new_w]
def step_gradient(b_current, w_current, points, learningRate):
b_gradient = torch.tensor(0.0, device=points.device, dtype=torch.float32)
w_gradient = torch.tensor(0.0, device=points.device, dtype=torch.float32)
N = float(len(points))
for i in range(len(points)):
x = points[i][0]
y = points[i][1]
b_gradient += -(2 / N) * (y - (w_current * x + b_current))
w_gradient += -(2 / N) * x * (y - (w_current * x + b_current))
new_b = b_current - (learningRate * b_gradient)
new_w = w_current - (learningRate * w_gradient)
return [new_b, new_w]
def gradient_descent_runner(points, starting_b, starting_w, learningRate, num_iterations):
b = torch.tensor(starting_b, device=points.device, dtype=torch.float32)
w = torch.tensor(starting_w, device=points.device, dtype=torch.float32)
for i in range(num_iterations):
b, w = step_gradient(b, w, points, learningRate)
return [b, w]
def run():
# 修改为生成数据的文件路径
points_np = np.genfromtxt("data1.csv", delimiter=',').astype(np.float32)
points = torch.tensor(points_np, device='mps')
learning_rate = 0.0001 # 使用较小的学习率
initial_b = 0.0
initial_w = 0.0
num_iterations = 1000
print("Starting gradient descent at b={0},w={1},error={2}".format(initial_b, initial_w,
compute_error_for_line_given_points(initial_b,
initial_w,
points)))
print("running...")
[b, w] = gradient_descent_runner(points, initial_b, initial_w, learning_rate, num_iterations)
print("After gradient descent at b={0},w={1},error={2}".format(b.item(), w.item(),
compute_error_for_line_given_points(b, w,
points)))
def gradient_descent_runner(points, starting_b, starting_w, learningRate, num_iterations):
b = torch.tensor(starting_b, device=points.device, dtype=torch.float32)
w = torch.tensor(starting_w, device=points.device, dtype=torch.float32)
for i in range(num_iterations):
b, w = step_gradient(b, w, points, learningRate)
return [b, w]
run()
def run1_cuda():
def compute_error_for_line_given_points(b, w, points):
totalError = 0
N = float(len(points))
for i in range(len(points)):
x = points[i][0]
y = points[i][1]
totalError += (y - (w * x + b)) ** 2
return totalError / N
def run():
# 修改为生成数据的文件路径
def step_gradient(b_current, w_current, points, learningRate):
b_gradient = torch.tensor(0.0, device=points.device)
w_gradient = torch.tensor(0.0, device=points.device)
N = float(len(points))
for i in range(len(points)):
x = points[i][0]
y = points[i][1]
b_gradient += -(2 / N) * (y - (w_current * x + b_current))
w_gradient += -(2 / N) * x * (y - (w_current * x + b_current))
new_b = b_current - (learningRate * b_gradient)
new_w = w_current - (learningRate * w_gradient)
return [new_b, new_w]
def gradient_descent_runner(points, starting_b, starting_w, learningRate, num_iterations):
b = torch.tensor(starting_b, device=points.device)
w = torch.tensor(starting_w, device=points.device)
for i in range(num_iterations):
b, w = step_gradient(b, w, points, learningRate)
print("round:", i)
return [b, w]
def run():
points_np = np.genfromtxt("data1.csv", delimiter=',').astype(np.float32)
points = torch.tensor(points_np, device='cuda')
learning_rate = 0.0001
initial_b = 0.0
initial_w = 0.0
num_iterations = 100000
[b, w] = gradient_descent_runner(points, initial_b, initial_w, learning_rate, num_iterations)
print("After gradient descent at b={0}, w={1}, error={2}".format(b.item(), w.item(),
compute_error_for_line_given_points(b, w,
points)))
return b.item(), w.item()
# 运行线性回归
final_b, final_w = run()
# 绘制图像
points_np = np.genfromtxt("data1.csv", delimiter=',').astype(np.float32)
points = torch.tensor(points_np, device='mps')
learning_rate = 0.0001 # 使用较小的学习率
initial_b = 0.0
initial_w = 0.0
num_iterations = 1000
print("Starting gradient descent at b={0},w={1},error={2}".format(initial_b, initial_w,
compute_error_for_line_given_points(initial_b,
initial_w,
points)))
print("running...")
[b, w] = gradient_descent_runner(points, initial_b, initial_w, learning_rate, num_iterations)
print("After gradient descent at b={0},w={1},error={2}".format(b.item(), w.item(),
compute_error_for_line_given_points(b, w, points)))
x = points_np[:, 0]
y = points_np[:, 1]
x_range = np.linspace(min(x), max(x), 100)
y_pred = final_w * x_range + final_b
plt.figure(figsize=(8, 6))
plt.scatter(x, y, color='blue', label='Original data')
plt.plot(x_range, y_pred, color='red', label='Fitted line')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Fitting a line to random data')
plt.legend()
plt.grid(True)
plt.savefig('print1.png')
plt.show()
def run1x():
# 线性回归训练代码
def compute_error_for_line_given_points(b, w, points):
totalError = 0
N = float(len(points))
for i in range(len(points)):
x = points[i][0]
y = points[i][1]
totalError += (y - (w * x + b)) ** 2
return totalError / N
def step_gradient(b_current, w_current, points, learningRate):
b_gradient = torch.tensor(0.0, device=points.device, dtype=torch.float32)
w_gradient = torch.tensor(0.0, device=points.device, dtype=torch.float32)
N = float(len(points))
for i in range(len(points)):
x = points[i][0]
y = points[i][1]
b_gradient += -(2 / N) * (y - (w_current * x + b_current))
w_gradient += -(2 / N) * x * (y - (w_current * x + b_current))
new_b = b_current - (learningRate * b_gradient)
new_w = w_current - (learningRate * w_gradient)
return [new_b, new_w]
def gradient_descent_runner(points, starting_b, starting_w, learningRate, num_iterations):
b = torch.tensor(starting_b, device=points.device, dtype=torch.float32)
w = torch.tensor(starting_w, device=points.device, dtype=torch.float32)
for i in range(num_iterations):
b, w = step_gradient(b, w, points, learningRate)
return [b, w]
def run():
points_np = np.genfromtxt("data1.csv", delimiter=',').astype(np.float32)
points = torch.tensor(points_np, device='mps')
learning_rate = 0.0001
initial_b = 0.0
initial_w = 0.0
num_iterations = 5000
[b, w] = gradient_descent_runner(points, initial_b, initial_w, learning_rate, num_iterations)
print("After gradient descent at b={0},w={1},error={2}".format(b.item(), w.item(),
compute_error_for_line_given_points(b, w,
points)))
return b.item(), w.item()
# 运行线性回归
final_b, final_w = run()
# 绘制图像
points_np = np.genfromtxt("data1.csv", delimiter=',').astype(np.float32)
x = points_np[:, 0]
y = points_np[:, 1]
x_range = np.linspace(min(x), max(x), 100)
y_pred = final_w * x_range + final_b
plt.figure(figsize=(8, 6))
plt.scatter(x, y, color='blue', label='Original data')
plt.plot(x_range, y_pred, color='red', label='Fitted line')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Fitting a line to random data')
plt.legend()
plt.grid(True)
plt.savefig('print1.png')
plt.show()
def run_m1():
# 检查是否支持MPS（Apple Metal Performance Shaders）
device = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
print(f"使用设备: {device}")
# 生成示例数据
# y = 3x + 2 + 噪声
torch.manual_seed(0)
X = torch.linspace(-10, 10, steps=100).reshape(-1, 1)
y = 3 * X + 2 + torch.randn(X.size()) * 2
# 创建数据集和数据加载器
dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=10, shuffle=True)
# 定义线性回归模型
class LinearRegressionModel(nn.Module):
def __init__(self):
super(LinearRegressionModel, self).__init__()
self.linear = nn.Linear(1, 1) # 输入和输出都是1维
def forward(self, x):
return self.linear(x)
# 实例化模型并移动到设备
model = LinearRegressionModel().to(device)
# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# 训练模型
num_epochs = 100
for epoch in range(num_epochs):
for batch_X, batch_y in dataloader:
batch_X = batch_X.to(device)
batch_y = batch_y.to(device)
# 前向传播
outputs = model(batch_X)
loss = criterion(outputs, batch_y)
# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (epoch + 1) % 10 == 0:
print(f"Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}")
# 保存整个模型
torch.save(model.state_dict(), 'm1.pth')
print("整个模型已保存为 m1.pth")
# 评估模型
model.eval()
with torch.no_grad():
X_test = torch.linspace(-10, 10, steps=100).reshape(-1, 1).to(device)
y_pred = model(X_test).cpu()
plt.scatter(X.numpy(), y.numpy(), label='真实数据')
plt.plot(X_test.cpu().numpy(), y_pred.numpy(), color='red', label='预测线')
plt.legend()
plt.xlabel('X')
plt.ylabel('y')
plt.title('线性回归结果')
plt.show()
def run_m1_test():
# 定义线性回归模型结构
class LinearRegressionModel(nn.Module):
def __init__(self):
super(LinearRegressionModel, self).__init__()
self.linear = nn.Linear(1, 1) # 输入和输出都是1维
def forward(self, x):
return self.linear(x)
def main():
# 检查是否支持MPS（Apple Metal Performance Shaders）
device = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
print(f"使用设备: {device}")
# 实例化模型并加载保存的模型参数
model = LinearRegressionModel().to(device)
model.load_state_dict(torch.load('m1.pth'))
with open('m1.pth', 'rb') as f:
f.seek(0, 2)
size = f.tell()
print(f"模型文件大小: {size} 字节")
model.eval()
# 输出模型大小
model_size = sum(p.numel() for p in model.parameters())
print(f"模型大小: {model_size} 个参数")
print("模型参数已加载")
# 生成测试数据
X_test = torch.linspace(-10, 10, steps=100).reshape(-1, 1).to(device)
# 使用加载的模型进行预测
with torch.no_grad():
y_pred = model(X_test).cpu()
# 将测试数据移至CPU并转换为NumPy数组
X_test_numpy = X_test.cpu().numpy()
y_pred_numpy = y_pred.numpy()
# 可视化预测结果
plt.scatter(X_test_numpy, 3 * X_test_numpy + 2, label='真实线性关系', color='blue')
plt.plot(X_test_numpy, y_pred_numpy, color='red', label='模型预测线')
plt.legend()
plt.xlabel('X')
plt.ylabel('y')
plt.title('加载模型后的线性回归预测结果')
plt.show()
main()
if __name__ == '__main__':
run()
print("start")