使用Pytorch完成逻辑回归问题 1.创建一些随机数据，并将其转换为Tensor类型 随机数据代码: np.random.seed(0) X = np.random.randn(100, 2) Y = np.zeros((100,)) Y[X[:,0] + X[:,1] > 0] = 1 2.定义一个逻辑回归模型（使用nn.Linear作为线性层，使用torch.sigmoid作为激活函数）； 3.定义损失函数（使用二元交叉熵损失函数）和优化器（使用随机梯度下降法）； 4.将模型训练指定轮数，每轮进行前向传播、反向传播和参数更新，并输出损失函数值； 5.输出模型参数并可视化结果。

以下是使用Pytorch完成逻辑回归问题的代码：

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# 创建随机数据，并将其转换为Tensor类型
np.random.seed(0)
X = torch.tensor(np.random.randn(100, 2), dtype=torch.float32)
Y = torch.tensor(np.zeros((100,)), dtype=torch.float32)
Y[X[:, 0] + X[:, 1] > 0] = 1

# 定义逻辑回归模型
class LogisticRegression(nn.Module):
    def __init__(self):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(2, 1)
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, x):
        x = self.linear(x)
        x = self.sigmoid(x)
        return x

# 定义损失函数和优化器
model = LogisticRegression()
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
losses = []
for epoch in range(num_epochs):
    optimizer.zero_grad()
    outputs = model(X)
    loss = criterion(outputs, Y)
    loss.backward()
    optimizer.step()
    
    losses.append(loss.item())
    if (epoch+1) % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# 输出模型参数
print('The trained parameters:')
for name, param in model.named_parameters():
    if param.requires_grad:
        print(name, param.data)

# 可视化结果
w, b = model.parameters()
w = w.detach().numpy()
b = b.detach().numpy()

plt.scatter(X[:, 0], X[:, 1], c=Y, cmap='bwr')
x1_min, x1_max = X[:, 0].min(), X[:, 0].max()
x2_min, x2_max = X[:, 1].min(), X[:, 1].max()
x1, x2 = np.meshgrid(np.linspace(x1_min, x1_max, 100), np.linspace(x2_min, x2_max, 100))
Z = 1 / (1 + np.exp(-(w[0]*x1 + w[1]*x2 + b)))
plt.contour(x1, x2, Z, levels=[0.5])
plt.show()

这个代码会输出逐步减少的损失函数值，训练完成后会输出模型参数，并将数据点和决策边界可视化。