PyTrch深度学习简明实战2 -逻辑回归 - 信用卡诈骗

笔记2：张笔记6：多分类问题（练习篇） - pbc的成长之路 - 博客园 (cnblogs.com)
量简介 - pbc的成长之路 - 博客园 (cnblogs.com)
笔记3：逻辑回归（分批次训练） - pbc的成长之路 - 博客园 (cnblogs.com)
笔记4：多层感知器（自定义模型） - pbc的成长之路 - 博客园 (cnblogs.com)
笔记5：TensorDataset、DataLoader及数据集划分 - pbc的成长之路 - 博客园 (cnblogs.com)
笔记6：多分类问题（练习篇） - pbc的成长之路 - 博客园 (cnblogs.com)
笔记7：训练过程封装（代码模板） - pbc的成长之路 - 博客园 (cnblogs.com)

# credit-a.csv
     0      1       2   3   4   5   6   ...  9   10  11  12   13     14  15
0     0  30.83   0.000   0   0   9   0  ...   0   1   1   0  202    0.0  -1
1     1  58.67   4.460   0   0   8   1  ...   0   6   1   0   43  560.0  -1
2     1  24.50   0.500   0   0   8   1  ...   1   0   1   0  280  824.0  -1
3     0  27.83   1.540   0   0   9   0  ...   0   5   0   0  100    3.0  -1
4     0  20.17   5.625   0   0   9   0  ...   1   0   1   2  120    0.0  -1
..   ..    ...     ...  ..  ..  ..  ..  ...  ..  ..  ..  ..  ...    ...  ..
648   0  21.08  10.085   1   1  11   1  ...   1   0   1   0  260    0.0   1
649   1  22.67   0.750   0   0   0   0  ...   0   2   0   0  200  394.0   1
650   1  25.25  13.500   1   1  13   7  ...   0   1   0   0  200    1.0   1
651   0  17.92   0.205   0   0  12   0  ...   1   0   1   0  280  750.0   1
652   0  35.00   3.375   0   0   0   1  ...   1   0   0   0    0    0.0   1

[653 rows x 16 columns]

# 信用卡欺诈数据分类

import torch
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from torch import nn

data = pd.read_csv('./credit-a.csv', header=None)
# print(data)

X = data.iloc[:,:-1]   # 提取数据集的前15列,即除了最后一列以外的所有列
Y = data.iloc[:,-1].replace(-1,0)    # 提取数据集的最后一列，目标值,并将-1替换为0

# 数据预处理，转化为tensor的形式
X = torch.from_numpy(X.values).type(torch.FloatTensor)      # 653行/15列，共15个特征
Y = torch.from_numpy(Y.values.reshape(-1,1)).type(torch.float32)    # reshape(-1,1) 表示变换成不限制行，只有1列,1个特征

# 创建模型
# nn.Sequential可以将多个层顺序连接在一起，形成模型
# 入门代码，用nn.Linear返回模型，因为那个模型是线性模型。
# 现在的模型已经非线性，给每个变量初始化一个权重与特征,之后再传入sigmoid。 线性回归的输出 加上 sigmoid，成为逻辑回归
model = nn.Sequential(
    nn.Linear(15,1),  # nn.Linear in_features=15, out_features=1; 第1层,线性层。   653行15列
    nn.Sigmoid()      # nn.Sigmoid  添加激活层,第2层； 将输入转换为概率；所有的层顺序链接
)
# 用nn.Sequential创建模型，里面可以添加多个层。nn.Sigmod适用的场景，是所有层都顺序链接，前一层的输出交给下一层，一次连接。
# print(model)
# Sequential(
#   (0): Linear(in_features=15, out_features=1, bias=True)
#   (1): Sigmoid()
# )

# 初始化损失函数，二元交叉熵损失
loss_fn = nn.BCELoss()

# 优化函数
# opt = torch.optim.SGD(model.parameters(), lr=0.00001)   # SGD是随机梯度下降，不考虑前面下降了多少。
opt = torch.optim.Adam(model.parameters(), lr=0.00001)   # 会综合考虑前面下降了多少。

# 训练，只是取出一部分数据进行训练。 小批次逐个batch进行训练，不可能将数据全部放下去训练，那样参数过多，硬件无法承受。
# 为什么不一张图片一张图片的训练？ 如果这样，就会对异常值极为敏感，导致loss剧烈震荡，用batch就可以避免这一点。
batches = 16
no_of_batches = 653//16    # 全部数据训练一边，需要653//16个批次

# epochs=1000： 将全部数据训练一遍，称之为一个epoch
for epoch in range(1000):
    for batch in range(no_of_batches):   # 一个批次一个批次进行训练
        start = batch*batches            # 第一轮从第0个batch开始，下一轮batch就变成1,...
        end = start + batches            # 每次的结束是start+batches
        x = X[start: end]
        y = Y[start: end]
        y_pred = model(x)
        loss = loss_fn(y_pred, y)
        opt.zero_grad()                 # 调用backward之前，需要将模型中所有变量的当前梯度置为0
        loss.backward()                 # 调用反向更新，计算每个变量的梯度
        opt.step()                      # 使用opt.step() 进行优化。

# 查看训练完后，模型的参数
print(model.state_dict())
# OrderedDict([('0.weight', tensor([[-8.2753e-02, -4.2353e-02,  1.2353e-02,  1.3594e-01,  3.9754e-01,
#           1.7541e-02,  3.7226e-01, -7.6392e-02,  4.3159e-01,  4.3930e-01,
#          -1.1473e-01,  1.2118e-01,  2.5670e-01,  3.3495e-03, -3.9232e-04]])), ('0.bias', tensor([0.1405]))])
# 输出15个weight，1个bias
# sigmoid(w1*x1 + w2*x2 + ... + w15*x15 + b)   这就是这个模型做的事情。

# 获取准确率
accu = ((model(X).data.numpy() > 0.5).astype('int') == Y.numpy()).mean()
# astype('int') numpy转换为int的方法
# 模型调用预测值X，并用.data取出预测值，.numpy()转换为numpy 就获得预测结果，为从0-1之间的小数值。
# (model(X).data.numpy() > 0.5) 大于0.5输出为1，小于0.5输出为0，.astype('int') 转换为int
# (model(X).data.numpy() > 0.5).astype('int')获得预测结果
# Y.numpy()为真实结果
# ((model(X).data.numpy() > 0.5).astype('int') == Y.numpy())  预测错误则值为0，预测正确值为1
# .mean()  直接求均值，获取的就是准确率。  所有的结果相加，再除以结果的数量

print(accu)
# 0.7932618683001531