提示：仅仅是学习记录笔记，搬运了学习课程的ppt内容，本意不是抄袭！望大家不要误解！纯属学习记录笔记！！！！！！
文章目录
前言
本节课程主要内容是：手动实现回归数据、二分类数据和多分类数据的创建、神经网络的定义和反向传播，以及tensorboardX的使用。目的是为了从更深层次了解神经网络的原理。关于在item里面激活虚拟环境的命令：conda activate 项目名；查看虚拟环境的项目：conda env list；删除虚拟环境的项目：conda remove -项目名 env_name --all；退出虚拟环境命令：conda deactivate。使用pycharm的话不需要这些命令，pycharm会自动激活虚拟环境。
一、深度学习建模实验中数据集创建函数的创建与使用
1、 创建回归类数据函数
生成线性相关数据y=2x1- x2 + b + 扰动项
#手动生成数据
num_inputs = 2 #特征个数
num_examples = 1000 #样本个数
torch.manual_seed(420) #设置随机种子
#线性方程系数
w_true = torch.tensor([2, -1.]).reshape(2, 1)
b_true = torch.tensor(1.)
#生成特征值和标签值
features = torch.randn(num_examples, num_inputs)
labels_true = torch.mm(features, w_true) + b_true
#生成了一个y=2x_1 - x_2 + b的正相关函数
#为我们的标签增加扰动项
lables = labels_true + torch.randn(size=labels_true.shape) * 0.01
plt.subplot(121) #从左往右数的第一个1表示生成一行图片，第二个数2表示生成两列图，第三个数1表示生成第一张图
plt.scatter(features[:, 0], lables) #查看第一个特征与标签之间的关系
plt.subplot(122)
plt.scatter(features[:, 1], lables) #查看第二个特征与标签之间的关系
print("finish")
plt.show()
不难看出，两个特征和标签都存在一定的线性关系，并且跟特征的系数绝对值有很大关系。当然，若要增加线性模型的建模难度，可以增加扰动项的数值比例，从而削弱线性关系。
torch.manual_seed(420)
#修改因变量
lables1 = labels_true + torch.randn(size=labels_true.shape) * 2
#可视化展示
plt.subplot(221) #从左往右数的第一个1表示生成一行图片，第二个数2表示生成两列图，第三个数1表示生成第一张图
plt.scatter(features[:, 0], lables) #查看第一个特征与标签之间的关系
plt.subplot(222)
plt.plot(features[:, 1], lables, 'ro') #查看第二个特征与标签之间的关系
plt.subplot(223)
plt.scatter(features[:, 0], lables1)
plt.subplot(224)
plt.plot(features[:, 1], lables1, 'yo')
plt.show()
明显可以看出，当我们扰动项比较大的时候，我们的点分布得更加分散。
生成非线性的数据集，y =w x ** 2 + b +扰动项
torch.manual_seed(420)
num_inputs = 2 #特征个数
num_examples = 1000 #样本个数
w_true = torch.tensor(2.)
b_true = torch.tensor(1.)
features = torch.randn(num_examples, num_inputs)
labels_true = torch.pow(features, 2) * w_true + b_true
lables2 = labels_true + torch.randn(size=labels_true.shape) * 0.1
plt.scatter(features, lables2)
plt.show()
创建回归数据生成函数
#创建生成数据的函数
def tensorGenReg(num_examples = 1000, w = [2, -1, 1], bias = True, delta = 0.01, deg = 1):
"""回归类数据集创建函数。
:param num_examples: 创建数据集的数据量
:param w: 包括截距的（如果存在）特征系数向量
:param bias：是否需要截距
:param delta：扰动项取值
:param deg：方程次数
:return: 生成的特征张和标签张量
"""
if bias == True:
num_inputs = len(w) - 1
features_true = torch.randn(num_examples, num_inputs)
w_true = torch.tensor(w[:-1]).reshape(-1, 1).float() # 自变量系数
b_true = torch.tensor(w[-1]).float()
if num_inputs == 1:
lable_true = torch.pow(features_true, deg) * w_true + b_true
else:
lable_true = torch.mm(torch.pow(features_true, deg), w_true) + b_true
l = torch.ones(len(features_true)).reshape(-1, 1)
features_true = torch.cat([features_true, l], dim=1)
labels = lable_true + torch.randn(size=(num_examples, 1)) * delta
else:
num_inputs = len(w)
features_true = torch.randn(num_examples, num_inputs)
w_true = torch.tensor(w).reshape(-1, 1).float()
if num_inputs == 1:
lable_true = torch.pow(features_true, deg) * w_true
else:
lable_true = torch.mm(torch.pow(features_true, deg), w_true)
labels = lable_true + torch.randn(size=(num_examples, 1)) * delta
return features_true, labels
torch.manual_seed(420)
f, l = tensorGenReg(delta=0.8)
print(f)
注：上述函数无法创建带有交叉项的方程
2、分类数据集创建方法
手动实现一个三分类数据集
torch.manual_seed(420)
num_input = 2
num_examples = 1000
#创建自变量簇
data0 = torch.normal(4, 2, size=(num_examples, num_input)) #生成均值为4，标准差为2的正太分布
data1 = torch.normal(-2, 2, size=(num_examples, num_input))
data2 = torch.normal(-6, 2, size=(num_examples, num_input))
#创建标签
label0 = torch.zeros(num_examples)
label1 = torch.ones(num_examples)
label2 = torch.full_like(label0, 2)
#合并生成最终数据
features = torch.cat((data0, data1, data2)).float()
labels = torch.cat((label0, label1, label2)).float()
plt.scatter(features[:, 0], features[:, 1], c = labels)
plt.show()
torch.manual_seed(420)
num_input = 2
num_examples = 1000
#创建自变量簇
data0 = torch.normal(4, 2, size=(num_examples, num_input)) #生成均值为4，标准差为2的正太分布
data1 = torch.normal(-2, 2, size=(num_examples, num_input))
data2 = torch.normal(-6, 2, size=(num_examples, num_input))
#创建标签
label0 = torch.zeros(num_examples)
label1 = torch.ones(num_examples)
label2 = torch.full_like(label0, 2)
# 创建自变量簇
data3 = torch.normal(3, 2, size=(num_examples, num_input))
data4 = torch.normal(0, 2, size=(num_examples, num_input))
data5 = torch.normal(-3, 2, size=(num_examples, num_input))
#合并生成最终数据
features = torch.cat((data0, data1, data2)).float()
labels = torch.cat((label0, label1, label2)).float()
features1 = torch.cat((data3, data4, data5)).float()
labels1 = torch.cat((label1, label2, label2)).long().reshape(-1, 1)
# 可视化展示
plt.subplot(121)
plt.scatter(features[:, 0], features[:, 1], c = labels)
plt.subplot(122)
plt.scatter(features1[:, 0], features1[:, 1], c = labels1)
plt.show()
创建分类数据生成函数
def tensorGenCla(num_example=500, num_input=2, num_class=3, deg_dispersion=[4, 2], bias=True):
"""分类数据集创建函数。
:param num_examples: 每个类别的数据数量
:param num_inputs: 数据集特征数量
:param num_class：数据集标签类别总数
:param deg_dispersion：数据分布离散程度参数，需要输入一个列表，其中第一个参数表示每个类别数组均值的参考、第二个参数表示随机数组标准差。
:param bias：建立模型逻辑回归模型时是否带入截距
:return: 生成的特征张量和标签张量，其中特征张量是浮点型二维数组，标签张量是长正型二维数组。
"""
cluster_l = torch.empty(num_example, 1)
mean_ = deg_dispersion[0]
std_ = deg_dispersion[1]
k = mean_ * (num_class-1)/2
lf = []
ll = []
for i in range(num_class):
data_temp = torch.normal(i * mean_ -k, std_, size=(num_example, num_input))
lf.append(data_temp)
labels_temp = torch.full_like(cluster_l, i)
ll.append(labels_temp)
features = torch.cat(lf).float()
labels = torch.cat(ll).float()
if bias == True:
l = torch.ones(len(features)).reshape(-1, 1)
features = torch.cat([features, l], dim=1)
return features, labels
3、创建小批量切分函数
def data_iter(batch_size, features, labels):
"""
数据切分函数
:param batch_size: 每个子数据集包含多少数据
:param featurs: 输入的特征张量
:param labels：输入的标签张量
:return l：包含batch_size个列表，每个列表切分后的特征和标签所组成
"""
num_examples = len(features)
indices = list(range(num_examples))
random.shuffle(indices)
l = []
for i in range(0, num_examples, batch_size):
j = torch.tensor(indices[i: min(i + batch_size, num_examples)])
l.append([torch.index_select(features, 0, j), torch.index_select(labels, 0, j)])
return l
二、PyTorch深度学习建模可视化工具TensorBoard的安装与使用
在终端输入pip install tensorboard，因为Mac的tensorboard为pytorch版本做了优化，所以不需要下载tensorboardX，接下来要进行实例化和写入数据： writer = SummaryWriter(log_dir=‘reg_loss’)，然后在epoch循环的每一批数据下面写下writer.add_scalar(‘mul’, train_l, epoch)，这样就可以查看每一轮的epoch的误差平方和的变化
writer = SummaryWriter(log_dir='reg_loss')
#训练过程
for epoch in range(num_epochs):
for X,y in data_iter(batch_size,features,labels):
l = loss(net(X, w), y)
l.backward()
sgd(w, lr)
train_l = loss(net(features, w), labels)
print('epoch %d, loss %f' % (epoch + 1, train_l))
writer.add_scalar('mul', train_l, epoch)
三、深度学习基础模型建模实验
1、线性回归建模实验
手动创建实现线性回归
import random
# 绘图模块
import matplotlib as mpl
import matplotlib.pyplot as plt
# numpy
import numpy as np
# pytorch
import torch
from torch import nn,optim
import torch.nn.functional as F
from torch.utils.data import Dataset,TensorDataset,DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchLearning import *
torch.manual_seed(420)
features, labels = tensorGenReg()
#建模流程
def linreg(X, w):
return torch.mm(X, w)
#确定目标函数
def squared_loss(y_hat, y):
num_ = y.numel()
sse = torch.sum((y_hat.reshape(-1, 1) - y.reshape(-1, 1)) ** 2)
return sse/ num_
#定义优化算法
def sgd(params, lr):
params.data -= lr * params.grad
params.grad.zero_()
#这里需要注意的是，params.data可以将参数矩阵提取出来，并在其原本结果上进行操作改变其原来的值。
#因为只要进行了backward(),w就被当作叶子节点来看待，不能在其本来的数值上进行操作，因为这会让pytorch分不清w到底是叶子节点还是中间节点
# 设置随机数种子
torch.manual_seed(420)
batch_size = 10 # 每一个小批的数量
lr = 0.03 # 学习率
num_epochs = 3 # 训练过程遍历几次数据
w = torch.zeros(3, 1, requires_grad = True) # 随机设置初始权重
net = linreg
loss = squared_loss
writer = SummaryWriter(log_dir='reg_loss')
#训练过程
for epoch in range(num_epochs):
for X,y in data_iter(batch_size,features,labels):
l = loss(net(X, w), y)
l.backward()
sgd(w, lr)
train_l = loss(net(features, w), labels)
print('epoch %d, loss %f' % (epoch + 1, train_l))
writer.add_scalar('mul', train_l, epoch)
老师的图
我的图···
线性回归的快速实现
import random
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import torch
from torch import nn,optim
import torch.nn.functional as F
from torch.utils.data import Dataset,TensorDataset,DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchLearning import *
batch_size = 10 # 每一个小批的数量
lr = 0.03 # 学习率
num_epochs = 3
# 设置随机数种子
torch.manual_seed(420)
# 创建数据集
features, labels = tensorGenReg()
features = features[:, :-1] # 剔除最后全是1的列
data = TensorDataset(features, labels) # 数据封装
batchData = DataLoader(data, batch_size = batch_size, shuffle = True) # 数据加载
class LR(nn.Module):
def __init__(self, in_features=2, out_features=1): # 定义模型的点线结构
super(LR, self).__init__()
self.linear = nn.Linear(in_features, out_features)
def forward(self, x): # 定义模型的正向传播规则
out = self.linear(x)
return out
# 实例化模型
LR_model = LR()
#Stage 2.定义损失函数
criterion = nn.MSELoss()
#- Stage 3.定义优化方法
optimizer = optim.SGD(LR_model.parameters(), lr = 0.03)
#- Stage 4.模型训练
writer = SummaryWriter(log_dir='reg_loss')
def fit(net, criterion, optimizer, batchdata, epochs):
for epoch in range(epochs):
for X, y in batchdata:
yhat = net.forward(X)
loss = criterion(yhat, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('epoch %d, loss %f' % (epoch + 1, loss))
writer.add_scalar('loss', loss, global_step=epoch)
torch.manual_seed(420)
fit(net = LR_model,
criterion = criterion,
optimizer = optimizer,
batchdata = batchData,
epochs = num_epochs)
2、逻辑回归建模实验
手动实现逻辑回归
import random
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import torch
from torch import nn,optim
import torch.nn.functional as F
from torch.utils.data import Dataset,TensorDataset,DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchLearning import *
#生成随机种子
torch.manual_seed(420)
#创建数据集
features, labels = tensorGenCla(num_class=2, bias=True)
#可视化展示
plt.scatter(features[:,0], features[:, 1], c=labels)
plt.show()
#激活函数
def sigmoid(z):
return 1/(1+torch.exp(-z))
#逻辑回归模型
def logistic(X,w):
return sigmoid(torch.mm(X, w))
#辅助函数
def cal(sigma, p=0.5):
return((sigma >= p).float())
def accuracy(sigma, y):
acc_bool = cal(sigma).flatten() == y.flatten()
acc = torch.mean(acc_bool.float())
return(acc)
def cross_entropy(sigma, y):
return(-(1/y.numel())*torch.sum((1-y)*torch.log(1-sigma)+y*torch.log(sigma)))
#定义优化方法
def sgd(params, lr):
params.data -= lr * params.grad
params.grad.zero_()
#- Stage 4.训练模型
# 设置随机数种子
torch.manual_seed(420)
# 初始化核心参数
batch_size = 10 # 每一个小批的数量
lr = 0.03 # 学习率
num_epochs = 3 # 训练过程遍历几次数据
w = torch.ones(3, 1, requires_grad = True) # 随机设置初始权重
# 参与训练的模型方程
net = logistic # 使用逻辑回归方程
loss = cross_entropy # 交叉熵损失函数
# 训练过程
for epoch in range(num_epochs):
for X, y in data_iter(batch_size, features, labels):
l = loss(net(X, w), y)
l.backward()
sgd(w, lr)
train_acc = accuracy(net(features, w), labels)
print('epoch %d, accuracy %f' % (epoch + 1, train_acc))
快速实现逻辑回归
import random
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import torch
from torch import nn,optim
import torch.nn.functional as F
from torch.utils.data import Dataset,TensorDataset,DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchLearning import *
batch_size = 10 # 每一个小批的数量
lr = 0.03 # 学习率
num_epochs = 3
torch.manual_seed(420)
# 创建数据集
features, labels = tensorGenCla(num_class=2)
features = features[:, :-1]
labels = labels.float() # 损失函数要求标签也必须是浮点型
data = TensorDataset(features, labels)
batchData = DataLoader(data, batch_size = batch_size, shuffle = True)
#print(features)
class logisticR(nn.Module):
def __init__(self, in_features=2, out_features=1): # 定义模型的点线结构
super(logisticR, self).__init__()
self.linear = nn.Linear(in_features, out_features)
def forward(self, x): # 定义模型的正向传播规则
out = self.linear(x)
return out
# 实例化模型和
logic_model = logisticR()
#Stage 2.定义损失函数
criterion = nn.BCEWithLogitsLoss()
#Stage 3.定义优化方法
optimizer = optim.SGD(logic_model.parameters(), lr = lr)
#- Stage 4.模型训练
def fit(net, criterion, optimizer, batchdata, epochs):
for epoch in range(epochs):
for X, y in batchdata:
zhat = net.forward(X)
loss = criterion(zhat, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 设置随机数种子
torch.manual_seed(420)
fit(net = logic_model,
criterion = criterion,
optimizer = optimizer,
batchdata = batchData,
epochs = num_epochs)
def sigmoid(z):
return 1/(1+torch.exp(-z))
#逻辑回归模型
def logistic(X,w):
return sigmoid(torch.mm(X, w))
#辅助函数
def cal(sigma, p=0.5):
return((sigma >= p).float())
def accuracy(sigma, y):
acc_bool = cal(sigma).flatten() == y.flatten()
acc = torch.mean(acc_bool.float())
return(acc)
def acc_zhat(zhat, y):
"""输入为线性方程计算结果，输出为逻辑回归准确率的函数
:param zhat：线性方程输出结果
:param y: 数据集标签张量
:return：准确率
"""
sigma = sigmoid(zhat)
return accuracy(sigma, y)
# 初始化核心参数
num_epochs = 20
LR1 = logisticR()
cr1 = nn.BCEWithLogitsLoss()
op1 = optim.SGD(LR1.parameters(), lr = lr)
# 创建列表容器
train_acc = []
# 执行建模
for epochs in range(num_epochs):
fit(net = LR1,
criterion = cr1,
optimizer = op1,
batchdata = batchData,
epochs = epochs)
epoch_acc = acc_zhat(LR1(features), labels)
train_acc.append(epoch_acc)
# 绘制图像查看准确率变化情况
plt.plot(list(range(num_epochs)), train_acc)
plt.show()
3、softmax回归建模实验
手动实现
# 自定义模块
from torchLearning import *
from matplotlib import pyplot
def max_x(x, delta=0.):
x = np.array(x)
negative_idx = x < delta
x[negative_idx] = 0.
return x
x = np.array(range(-10, 10))
s_j = np.array(x)
hinge_loss = max_x(s_j, delta=1.)
pyplot.plot(s_j, hinge_loss)
pyplot.title("Max Function")
pyplot.show()
def cross_entropy_test(s_k, s_j):
soft_max = 1/(1+np.exp(s_k - s_j))
cross_entropy_loss = -np.log(soft_max)
return cross_entropy_loss
s_i = 0
s_k = np.array(range(-10, 10))
soft_x = cross_entropy_test(s_k, s_i)
pyplot.plot(x, hinge_loss)
pyplot.plot(range(-10, 10), soft_x)
pyplot.title("softmax vs Max")
pyplot.show()
#1.生成数据集
# 设置随机数种子
torch.manual_seed(420)
features, labels = tensorGenCla(bias=True, deg_dispersion=[6, 2])
plt.scatter(features[:, 0], features[:, 1], c = labels)
plt.show()
def softmax(X, w):
m = torch.exp(torch.mm(X, w))
sp = torch.sum(m, 1).reshape(-1, 1)
return m / sp
def m_cross_entropy(soft_z, y):
y = y.long()
prob_real = torch.gather(soft_z, 1, y)
return (-(1/y.numel()) * torch.log(prob_real).sum())
def m_accuracy(soft_z, y):
acc_bool = torch.argmax(soft_z, 1).flatten() == y.flatten()
acc = torch.mean(acc_bool.float())
return(acc)
def sgd(params, lr):
params.data -= lr * params.grad
params.grad.zero_()
# 设置随机数种子
torch.manual_seed(420)
# 数值创建
features, labels = tensorGenCla(bias = True, deg_dispersion = [6, 2])
plt.scatter(features[:, 0], features[:, 1], c = labels)
#plt.show()
# 设置随机数种子
torch.manual_seed(420)
# 初始化核心参数
batch_size = 10 # 每一个小批的数量
lr = 0.03 # 学习率
num_epochs = 3 # 训练过程遍历几次数据
w = torch.randn(3, 3, requires_grad = True) # 随机设置初始权重
# 参与训练的模型方程
net = softmax # 使用回归方程
loss = m_cross_entropy # 交叉熵损失函数
train_acc = []
# 模型训练过程
for epoch in range(num_epochs):
for X, y in data_iter(batch_size, features, labels):
l = loss(net(X, w), y)
l.backward()
sgd(w, lr)
train_acc = m_accuracy(net(features, w), labels)
print('epoch %d, acc %f' % (epoch + 1, train_acc))
快速实现
# 设置随机数种子
torch.manual_seed(420)
batch_size = 10 # 每一个小批的数量
lr = 0.03 # 学习率
num_epochs = 3
# 创建数据集
features, labels = tensorGenCla(deg_dispersion = [6, 2])
labels = labels.float() # 损失函数要求标签也必须是浮点型
features = features[:, :-1]
data = TensorDataset(features, labels)
batchData = DataLoader(data, batch_size = batch_size, shuffle = True)
#print(features)
class softmaxR(nn.Module):
def __init__(self, in_features=2, out_features=3, bias=False): # 定义模型的点线结构
super(softmaxR, self).__init__()
self.linear = nn.Linear(in_features, out_features)
def forward(self, x): # 定义模型的正向传播规则
out = self.linear(x)
return out
# 实例化模型和
softmax_model = softmaxR()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(softmax_model.parameters(), lr = lr)
def fit(net, criterion, optimizer, batchdata, epochs):
for epoch in range(epochs):
for X, y in batchdata:
zhat = net.forward(X)
y = y.flatten().long() # 损失函数计算要求转化为整数
loss = criterion(zhat, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
fit(net = softmax_model,
criterion = criterion,
optimizer = optimizer,
batchdata = batchData,
epochs = num_epochs)
#print(softmax_model)
# 设置随机数种子
torch.manual_seed(420)
def m_accuracy(soft_z, y):
acc_bool = torch.argmax(soft_z, 1).flatten() == y.flatten()
acc = torch.mean(acc_bool.float())
return(acc)
# 初始化核心参数
num_epochs = 20
SF1 = softmaxR()
cr1 = nn.CrossEntropyLoss()
op1 = optim.SGD(SF1.parameters(), lr = lr)
# 创建列表容器
train_acc = []
# 执行建模
for epochs in range(num_epochs):
fit(net = SF1,
criterion = cr1,
optimizer = op1,
batchdata = batchData,
epochs = epochs)
epoch_acc = m_accuracy(F.softmax(SF1(features), 1), labels)
train_acc.append(epoch_acc)
# 绘制图像查看准确率变化情况
plt.plot(list(range(num_epochs)), train_acc)
plt.show()
扫一扫
440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
