线性回归和逻辑回归代码

import torch
import torch.nn as nn
import numpy as np
from sklearn import datasets
import matplotlib.pyplot as plt

#0)prpare data
X_numpy, y_numpy = datasets.make_regression(n_samples=100, n_features=1, noise=20, random_state=1)
X = torch.from_numpy(X_numpy.astype(np.float32))
y = torch.from_numpy(y_numpy.astype(np.float32))
# print(y.shape) #torch.Size([100])
# print(X.shape) #torch.Size([100, 1])
# print(y.shape[0])#100
y = y.view(y.shape[0], 1)
# # 效果 [1, 2]  ----> [[1], [2]]
# print(y.shape)  #torch.Size([100, 1])
#
n_samples, n_features = X.shape  # n_samples = 100 n_features = 1
#
# #1)model
input_size = n_features  # n_features = 1
output_size = 1
model = nn.Linear(input_size, output_size)
# #
# # #2)loss and optimizer
# # optimizer
learning_rate = 0.01
criterion = nn.MSELoss()    # 英 / kraɪˈtɪəriən MSE:mean square error
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
# #
# #3)training loop
num_epoches = 100
for epoch in range(num_epoches):
    # forward pass and loss
    y_predicted = model(X)
    loss = criterion(y_predicted, y)

    # backward pass
    loss.backward()

    # update
    optimizer.step()

    optimizer.zero_grad()

    if (epoch + 1) % 10 == 0:
        print(f'epoch:{epoch + 1}, loss = {loss.item():.4f}')
# plot
# print(type(model(X)))
# print(type(model(X).detach()))
# print(type(model(X).detach().numpy()))
'''
<class 'torch.Tensor'> ps: grad = true
<class 'torch.Tensor'> ps: grad = false 
<class 'numpy.ndarray'>
'''
# print(X_numpy.shape)    # (100, 1)
predicted = model(X).detach().numpy()
# 使用detach()关闭张量X自动优化梯度
# 否则报错 RuntimeError: Can't call numpy() on Tensor that requires grad. Use tensor.detach().numpy() instead.

plt.plot(X_numpy, y_numpy, 'ro') # ro 各个离散点以点的形式呈现
plt.plot(X_numpy, predicted, 'b') # b 各个离散点连起来
'''
经调试
其中plot的参数可以是tensor也可以是numpy
形状可以是[100, 1]也可以是[100]
'''
plt.show()

程序输出 绘图结果

import torch
import torch.nn as nn
import numpy as np
from sklearn import datasets
from sklearn.preprocessing import StandardScaler  # 对数据做特征处理
from sklearn.model_selection import train_test_split  # 分离数据为训练和测试集

# 0)prepare the data
bc = datasets.load_breast_cancer()
X, y = bc.data, bc.target

n_samples, n_features = X.shape
# print(n_samples, n_features)#569 30

# scale
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234)  # 分离数据
sc = StandardScaler()  # 标准归一化处理 如：华氏度、摄氏度单位统一
X_train = sc.fit_transform(X_train)  # fit找到规则并做变换
X_test = sc.fit_transform(X_test) #以前面fit找到的规则做变换
# print(type(X_train))
# <class 'numpy.ndarray'>
X_train = torch.from_numpy(X_train.astype(np.float32))
X_test = torch.from_numpy(X_test.astype(np.float32))
y_train = torch.from_numpy(y_train.astype(np.float32))
y_test = torch.from_numpy(y_test.astype(np.float32))
# print(y_train)
y_train = y_train.view(y_train.shape[0], 1)
y_test = y_test.view(y_test.shape[0], 1)


# print(y_train.shape[0])
# 经过变换，y_train从行向量变为了列向量
# print(y_train)
# print(type(X_train))
# <class 'torch.Tensor'>


# 1)model
# f = wx + b, sigmoid function at the end
class LogisticRegression(nn.Module):
    def __init__(self, n_input_features):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(n_input_features, 1)

    def forward(self, x):
        y_predicted = torch.sigmoid(self.linear(x))
        return y_predicted


model = LogisticRegression(n_features)

# 2)loss and optimizer
learning_rate = 0.01
criterion = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
# 3)training loop
num_epochs = 100
for epoch in range(num_epochs):
    # forward pass and loss
    y_predicted = model(X_train)
    loss = criterion(y_predicted, y_train)
    # backward pass
    loss.backward()
    # updates
    optimizer.step()

    # zero gradients
    optimizer.zero_grad()

    if (epoch + 1) % 10 == 0:
        print(f'epoch:{epoch+1}, loss = {loss.item():.4f}')

with torch.no_grad():  # 只是想得到网络的结果，而不想再继续通过输出优化网络
    y_predicted = model(X_test)
    y_predicted_cls = y_predicted.round()
    acc = y_predicted_cls.eq(y_test).sum() / float(y_test.shape[0])
    print(f'accuracy = {acc:4f}')