Browse Source

Pre Merge pull request !14 from xiazhenyu/master

pull/14/MERGE
xiazhenyu Gitee 3 years ago
parent
commit
9d46922e89
5 changed files with 638 additions and 0 deletions
  1. +238
    -0
      6_pytorch/fig-res-8.2.py
  2. +86
    -0
      6_pytorch/fig-res-8.3.py
  3. +91
    -0
      6_pytorch/fig-res-8.4.py
  4. +107
    -0
      6_pytorch/fig-res-8.5.py
  5. +116
    -0
      6_pytorch/fig-res-8.6.py

+ 238
- 0
6_pytorch/fig-res-8.2.py View File

@@ -0,0 +1,238 @@
import torch
import numpy as np
from torch import nn
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt

#%matplotlib inline
np.random.seed(1)
m = 400 # 样本数量
N = int(m/2) # 每一类的点的个数
D = 2 # 维度
x = np.zeros((m, D))
y = np.zeros((m, 1), dtype='uint8') # label 向量, 0 表示红色, 1 表示蓝色
a = 4

# 生成两类数据
for j in range(2):
ix = range(N*j,N*(j+1))
t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta
r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius
x[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
y[ix] = j

plt.ylabel("x2")
plt.xlabel("x1")
# 绘出生成的数据
for i in range(m):
if y[i] == 0:
plt.scatter(x[i, 0], x[i, 1], marker='8',c=0, s=40, cmap=plt.cm.Spectral)
else:
plt.scatter(x[i, 0], x[i, 1], marker='^',c=1, s=40)
plt.savefig('fig-res-8.2.pdf')
plt.show()
# #尝试用逻辑回归解决
# x = torch.from_numpy(x).float()
# y = torch.from_numpy(y).float()

# w = nn.Parameter(torch.randn(2, 1))
# b = nn.Parameter(torch.zeros(1))

# # [w,b]是模型的参数; 1e-1是学习速率
# optimizer = torch.optim.SGD([w, b], 1e-1)
# criterion = nn.BCEWithLogitsLoss()
# def logistic_regression(x):
# return torch.mm(x, w) + b


# for e in range(100):
# # 模型正向计算
# out = logistic_regression(Variable(x))
# # 计算误差
# loss = criterion(out, Variable(y))
# # 误差反传和参数更新
# optimizer.zero_grad()
# loss.backward()
# optimizer.step()
# if (e + 1) % 20 == 0:
# print('epoch:{}, loss:{}'.format(e+1, loss.item()))


# def plot_decision_boundary(model, x, y):
# # Set min and max values and give it some padding
# x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1
# y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1
# h = 0.01
# # Generate a grid of points with distance h between them
# xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min,y_max, h))

# # Predict the function value for the whole grid .c_ 按行连接两个矩阵,左右相加。
# Z = model(np.c_[xx.ravel(), yy.ravel()])
# Z = Z.reshape(xx.shape)
# # Plot the contour and training examples
# plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
# plt.ylabel("x2")
# plt.xlabel("x1")
# plt.scatter(x[:, 0], x[:, 1], c=y.reshape(-1), s=40, cmap=plt.cm.Spectral)

# def plot_logistic(x):
# x = Variable(torch.from_numpy(x).float())
# out = F.sigmoid(logistic_regression(x))
# out = (out > 0.5) * 1
# return out.data.numpy()

# plot_decision_boundary(lambda x: plot_logistic(x), x.numpy(), y.numpy())
# plt.title('logistic regression')
# plt.savefig('fig-res-8.3.pdf')


# # 定义两层神经网络的参数
# w1 = nn.Parameter(torch.randn(2, 4) * 0.01) # 输入维度为2, 隐藏层神经元个数4
# b1 = nn.Parameter(torch.zeros(4))
# w2 = nn.Parameter(torch.randn(4, 1) * 0.01) # 隐层神经元为4, 输出单元为1
# b2 = nn.Parameter(torch.zeros(1))

# def mlp_network(x):
# x1 = torch.mm(x, w1) + b1
# x1 = F.tanh(x1) # 使用 PyTorch 自带的 tanh 激活函数
# x2 = torch.mm(x1, w2) + b2
# return x2

# # 定义优化器和损失函数
# optimizer = torch.optim.SGD([w1, w2, b1, b2], 1.)
# criterion = nn.BCEWithLogitsLoss()

# for e in range(10000):
# # 正向计算
# out = mlp_network(Variable(x))
# # 计算误差
# loss = criterion(out, Variable(y))
# # 计算梯度并更新权重
# optimizer.zero_grad()
# loss.backward()
# optimizer.step()
# if (e + 1) % 1000 == 0:
# print('epoch: {}, loss: {}'.format(e+1, loss.item()))

# def plot_network(x):
# x = Variable(torch.from_numpy(x).float())
# x1 = torch.mm(x, w1) + b1
# x1 = F.tanh(x1)
# x2 = torch.mm(x1, w2) + b2
# out = F.sigmoid(x2)
# out = (out > 0.5) * 1
# return out.data.numpy()

# plot_decision_boundary(lambda x: plot_network(x), x.numpy(), y.numpy())
# plt.title('2 layer network')
# plt.savefig('fig-res-8.4.pdf')

# # Sequential
# seq_net = nn.Sequential(
# nn.Linear(2, 4), # PyTorch 中的线性层, wx + b
# nn.Tanh(),
# nn.Linear(4, 1)
# )

# # 序列模块可以通过索引访问每一层
# seq_net[0] # 第一层

# # 打印出第一层的权重
# w0 = seq_net[0].weight
# print(w0)


# # 通过 parameters 可以取得模型的参数
# param = seq_net.parameters()
# # 定义优化器
# optim = torch.optim.SGD(param, 1.)

# # 训练 10000 次
# for e in range(10000):
# # 网络正向计算
# out = seq_net(Variable(x))
# # 计算误差
# loss = criterion(out, Variable(y))
# # 反向传播、 更新权重
# optim.zero_grad()
# loss.backward()
# optim.step()
# # 打印损失
# if (e + 1) % 1000 == 0:
# print('epoch: {}, loss: {}'.format(e+1, loss.item()))


# def plot_seq(x):
# out = F.sigmoid(seq_net(Variable(torch.from_numpy(x).float()))).data.numpy()
# out = (out > 0.5) * 1
# return out

# plot_decision_boundary(lambda x: plot_seq(x), x.numpy(), y.numpy())
# plt.title('sequential')
# plt.savefig('fig-res-8.5.pdf')

# torch.save(seq_net, 'save_seq_net.pth')

# # 读取保存的模型
# seq_net1 = torch.load('save_seq_net.pth')
# # 打印加载的模型
# seq_net1

# print(seq_net1[0].weight)

# # 保存模型参数
# torch.save(seq_net.state_dict(), 'save_seq_net_params.pth')

# # 定义网络架构
# seq_net2 = nn.Sequential(
# nn.Linear(2, 4),
# nn.Tanh(),
# nn.Linear(4, 1)
# )
# # 加载网络参数
# seq_net2.load_state_dict(torch.load('save_seq_net_params.pth'))

# # 打印网络结构
# seq_net2
# print(seq_net2[0].weight)

# class Module_Net(nn.Module):
# def __init__(self, num_input, num_hidden, num_output):
# super(Module_Net, self).__init__()
# self.layer1 = nn.Linear(num_input, num_hidden)
# self.layer2 = nn.Tanh()
# self.layer3 = nn.Linear(num_hidden, num_output)

# def forward(self, x):
# x = self.layer1(x)
# x = self.layer2(x)
# x = self.layer3(x)
# return x

# mo_net = Module_Net(2, 4, 1)
# # 访问模型中的某层可以直接通过名字, 网络第一层
# l1 = mo_net.layer1
# print(l1)


# optim = torch.optim.SGD(mo_net.parameters(), 1.)
# # 训练 10000 次
# for e in range(10000):
# # 网络正向计算
# out = mo_net(Variable(x))
# # 计算误差
# loss = criterion(out, Variable(y))
# # 误差反传、 更新参数
# optim.zero_grad()
# loss.backward()
# optim.step()
# # 打印损失
# if (e + 1) % 1000 == 0:
# print('epoch: {}, loss: {}'.format(e+1, loss.item()))

# torch.save(mo_net.state_dict(), 'module_net.pth')





+ 86
- 0
6_pytorch/fig-res-8.3.py View File

@@ -0,0 +1,86 @@
import torch
import numpy as np
from torch import nn
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False

#%matplotlib inline
np.random.seed(1)
m = 400 # 样本数量
N = int(m/2) # 每一类的点的个数
D = 2 # 维度
x = np.zeros((m, D))
y = np.zeros((m, 1), dtype='uint8') # label 向量, 0 表示红色, 1 表示蓝色
a = 4

# 生成两类数据
for j in range(2):
ix = range(N*j,N*(j+1))
t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta
r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius
x[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
y[ix] = j

#尝试用逻辑回归解决
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()

w = nn.Parameter(torch.randn(2, 1))
b = nn.Parameter(torch.zeros(1))

# [w,b]是模型的参数; 1e-1是学习速率
optimizer = torch.optim.SGD([w, b], 1e-1)
criterion = nn.BCEWithLogitsLoss()
def logistic_regression(x):
return torch.mm(x, w) + b


for e in range(100):
# 模型正向计算
out = logistic_regression(Variable(x))
# 计算误差
loss = criterion(out, Variable(y))
# 误差反传和参数更新
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (e + 1) % 20 == 0:
print('epoch:{}, loss:{}'.format(e+1, loss.item()))


def plot_decision_boundary(model, x, y):
# Set min and max values and give it some padding
x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1
y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1
h = 0.01
# Generate a grid of points with distance h between them
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min,y_max, h))

# Predict the function value for the whole grid .c_ 按行连接两个矩阵,左右相加。
Z = model(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# Plot the contour and training examples
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.ylabel("x2")
plt.xlabel("x1")
for i in range(m):
if y[i] == 0:
plt.scatter(x[i, 0], x[i, 1], marker='8',c=0, s=40, cmap=plt.cm.Spectral)
else:
plt.scatter(x[i, 0], x[i, 1], marker='^',c=1, s=40)


def plot_logistic(x):
x = Variable(torch.from_numpy(x).float())
out = F.sigmoid(logistic_regression(x))
out = (out > 0.5) * 1
return out.data.numpy()

plot_decision_boundary(lambda x: plot_logistic(x), x.numpy(), y.numpy())
plt.title('逻辑回归')
plt.savefig('fig-res-8.3.pdf')
plt.show()

+ 91
- 0
6_pytorch/fig-res-8.4.py View File

@@ -0,0 +1,91 @@
import torch
import numpy as np
from torch import nn
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False
#%matplotlib inline
np.random.seed(1)
m = 400 # 样本数量
N = int(m/2) # 每一类的点的个数
D = 2 # 维度
x = np.zeros((m, D))
y = np.zeros((m, 1), dtype='uint8') # label 向量, 0 表示红色, 1 表示蓝色
a = 4

# 生成两类数据
for j in range(2):
ix = range(N*j,N*(j+1))
t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta
r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius
x[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
y[ix] = j

x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()

# 定义两层神经网络的参数
w1 = nn.Parameter(torch.randn(2, 4) * 0.01) # 输入维度为2, 隐藏层神经元个数4
b1 = nn.Parameter(torch.zeros(4))
w2 = nn.Parameter(torch.randn(4, 1) * 0.01) # 隐层神经元为4, 输出单元为1
b2 = nn.Parameter(torch.zeros(1))

def mlp_network(x):
x1 = torch.mm(x, w1) + b1
x1 = F.tanh(x1) # 使用 PyTorch 自带的 tanh 激活函数
x2 = torch.mm(x1, w2) + b2
return x2

# 定义优化器和损失函数
optimizer = torch.optim.SGD([w1, w2, b1, b2], 1.)
criterion = nn.BCEWithLogitsLoss()

for e in range(10000):
# 正向计算
out = mlp_network(Variable(x))
# 计算误差
loss = criterion(out, Variable(y))
# 计算梯度并更新权重
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (e + 1) % 1000 == 0:
print('epoch: {}, loss: {}'.format(e+1, loss.item()))

def plot_decision_boundary(model, x, y):
# Set min and max values and give it some padding
x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1
y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1
h = 0.01
# Generate a grid of points with distance h between them
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min,y_max, h))

# Predict the function value for the whole grid .c_ 按行连接两个矩阵,左右相加。
Z = model(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# Plot the contour and training examples
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.ylabel("x2")
plt.xlabel("x1")
for i in range(m):
if y[i] == 0:
plt.scatter(x[i, 0], x[i, 1], marker='8',c=0, s=40, cmap=plt.cm.Spectral)
else:
plt.scatter(x[i, 0], x[i, 1], marker='^',c=1, s=40)

def plot_network(x):
x = Variable(torch.from_numpy(x).float())
x1 = torch.mm(x, w1) + b1
x1 = F.tanh(x1)
x2 = torch.mm(x1, w2) + b2
out = F.sigmoid(x2)
out = (out > 0.5) * 1
return out.data.numpy()

plot_decision_boundary(lambda x: plot_network(x), x.numpy(), y.numpy())
plt.title('2层神经网络')
plt.savefig('fig-res-8.4.pdf')
plt.show()

+ 107
- 0
6_pytorch/fig-res-8.5.py View File

@@ -0,0 +1,107 @@
import torch
import numpy as np
from torch import nn
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
import matplotlib as mpl

plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False

#%matplotlib inline
np.random.seed(1)
m = 400 # 样本数量
N = int(m/2) # 每一类的点的个数
D = 2 # 维度
x = np.zeros((m, D))
y = np.zeros((m, 1), dtype='uint8') # label 向量, 0 表示红色, 1 表示蓝色
a = 4

criterion = nn.BCEWithLogitsLoss()

# 生成两类数据
for j in range(2):
ix = range(N*j,N*(j+1))
t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta
r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius
x[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
y[ix] = j


def plot_decision_boundary(model, x, y):
# Set min and max values and give it some padding
x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1
y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1
h = 0.01
# Generate a grid of points with distance h between them
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min,y_max, h))

# Predict the function value for the whole grid .c_ 按行连接两个矩阵,左右相加。
Z = model(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# Plot the contour and training examples
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.ylabel("x2")
plt.xlabel("x1")
for i in range(m):
if y[i] == 0:
plt.scatter(x[i, 0], x[i, 1], marker='8',c=0, s=40, cmap=plt.cm.Spectral)
else:
plt.scatter(x[i, 0], x[i, 1], marker='^',c=1, s=40)

#尝试用逻辑回归解决
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()


# Sequential
seq_net = nn.Sequential(
nn.Linear(2, 4), # PyTorch 中的线性层, wx + b
nn.Tanh(),
nn.Linear(4, 1)
)

# 序列模块可以通过索引访问每一层
seq_net[0] # 第一层

# 打印出第一层的权重
w0 = seq_net[0].weight
print(w0)


# 通过 parameters 可以取得模型的参数
param = seq_net.parameters()
# 定义优化器
optim = torch.optim.SGD(param, 1.)

# 训练 10000 次
for e in range(10000):
# 网络正向计算
out = seq_net(Variable(x))
# 计算误差
loss = criterion(out, Variable(y))
# 反向传播、 更新权重
optim.zero_grad()
loss.backward()
optim.step()
# 打印损失
if (e + 1) % 1000 == 0:
print('epoch: {}, loss: {}'.format(e+1, loss.item()))


def plot_seq(x):
out = F.sigmoid(seq_net(Variable(torch.from_numpy(x).float()))).data.numpy()
out = (out > 0.5) * 1
return out

plot_decision_boundary(lambda x: plot_seq(x), x.numpy(), y.numpy())
mpl.rcParams['font.family'] = 'SimHei'
plt.rcParams['axes.unicode_minus'] = False

# plt.title('序列化网络')
# plt.savefig('fig-res-8.5.pdf')
plt.title('模块定义网络')
plt.savefig('fig-res-8.6.pdf')
plt.show()
torch.save(seq_net, 'save_seq_net.pth')

+ 116
- 0
6_pytorch/fig-res-8.6.py View File

@@ -0,0 +1,116 @@
import torch
import numpy as np
from torch import nn
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt

#%matplotlib inline
np.random.seed(1)
m = 400 # 样本数量
N = int(m/2) # 每一类的点的个数
D = 2 # 维度
x = np.zeros((m, D))
y = np.zeros((m, 1), dtype='uint8') # label 向量, 0 表示红色, 1 表示蓝色
a = 4

criterion = nn.BCEWithLogitsLoss()

# 生成两类数据
for j in range(2):
ix = range(N*j,N*(j+1))
t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta
r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius
x[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
y[ix] = j


def plot_decision_boundary(model, x, y):
# Set min and max values and give it some padding
x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1
y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1
h = 0.01
# Generate a grid of points with distance h between them
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min,y_max, h))

# Predict the function value for the whole grid .c_ 按行连接两个矩阵,左右相加。
Z = model(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# Plot the contour and training examples
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.ylabel("x2")
plt.xlabel("x1")
for i in range(m):
if y[i] == 0:
plt.scatter(x[i, 0], x[i, 1], marker='8',c=0, s=40, cmap=plt.cm.Spectral)
else:
plt.scatter(x[i, 0], x[i, 1], marker='^',c=1, s=40)

#尝试用逻辑回归解决
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()

seq_net = nn.Sequential(
nn.Linear(2, 4), # PyTorch 中的线性层, wx + b
nn.Tanh(),
nn.Linear(4, 1)
)

# 读取保存的模型
seq_net1 = torch.load('save_seq_net.pth')
# 打印加载的模型
seq_net1

print(seq_net1[0].weight)

# 保存模型参数
torch.save(seq_net.state_dict(), 'save_seq_net_params.pth')

# 定义网络架构
seq_net2 = nn.Sequential(
nn.Linear(2, 4),
nn.Tanh(),
nn.Linear(4, 1)
)
# 加载网络参数
seq_net2.load_state_dict(torch.load('save_seq_net_params.pth'))

# 打印网络结构
seq_net2
print(seq_net2[0].weight)

class Module_Net(nn.Module):
def __init__(self, num_input, num_hidden, num_output):
super(Module_Net, self).__init__()
self.layer1 = nn.Linear(num_input, num_hidden)
self.layer2 = nn.Tanh()
self.layer3 = nn.Linear(num_hidden, num_output)

def forward(self, x):
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
return x

mo_net = Module_Net(2, 4, 1)
# 访问模型中的某层可以直接通过名字, 网络第一层
l1 = mo_net.layer1
print(l1)


optim = torch.optim.SGD(mo_net.parameters(), 1.)
# 训练 10000 次
for e in range(10000):
# 网络正向计算
out = mo_net(Variable(x))
# 计算误差
loss = criterion(out, Variable(y))
# 误差反传、 更新参数
optim.zero_grad()
loss.backward()
optim.step()
# 打印损失
if (e + 1) % 1000 == 0:
print('epoch: {}, loss: {}'.format(e+1, loss.item()))

torch.save(mo_net.state_dict(), 'module_net.pth')

Loading…
Cancel
Save