回归问题:
求最优的w,b
import numpy as np
import pandas as pd
# y = wx + b
def compute_error_for_line_given_points(b,w,points):# 计算损失
totalError = 0
for i in range(len(points)):
x = points[i,0]
y = points[i,1]
totalError += (y - (w*x + b))**2
return totalError / float(len(points))
def step_gradient(b_current,w_current,points,learningRate): # 计算梯度
b_gradient = 0
w_gradient = 0
N = float(len(points))
for i in range(len(points)):
x = points[i,0]
y = points[i,1]
b_gradient += -(2/N)*(y-((w_current*x) + b_current))# 在式子中对b求导,在求平均,
w_gradient += -(2/N) * (y-((w_current*x) + b_current)) * x
new_b = b_current - (learningRate*b_gradient)# 更新新的b,w
new_w = w_current - (learningRate * w_gradient)
return [new_w,new_b]
def gradient_descent_runner(points,starting_b,starting_w,learning_rate,num_iterations):
"""
迭代更新 w,b
:param points:
:param starting_b:
:param starting_w:
:param learning_rate:
:param num_iterations:
:return:
"""
b = starting_b
w = starting_w
for i in range(num_iterations):
b,w = step_gradient(b,w,np.array(points),learning_rate)
return [w,b]
def run():
# points = pd.read_csv('data.csv')
points = np.genfromtxt("data.csv", delimiter=",")
# print(points)
learning_rate = 0.0001
initial_b = 0 # 预测最初的b,w
initial_w = 0
num_iterations = 1000
print('开始梯度下降时,b = {},m = {},error={}'
.format(initial_b,initial_w,
compute_error_for_line_given_points(initial_b,initial_w,points)))
print('Running...')
[b,w] = gradient_descent_runner(points,initial_b,initial_w,learning_rate,num_iterations)
print('经过 {0} 次迭代,最终的 b = {1},w = {2},error = {3}'
.format(num_iterations,b,w,compute_error_for_line_given_points(b,w,points)))
if __name__ == '__main__':
run()
分类问题:
最后求得的是维度
手写数字识别器
import torch
from torch import nn # 神经网络相关工作
from torch.nn import functional as F #
from torch import optim # 优化工具包
import torchvision # 视觉相关数据包
import matplotlib.pyplot as plt
from utils import plot_image,plot_curve,one_hot
# 加载数据
batch_size = 512
train_loader = torch.utils.data.DataLoader(
torchvision.datasets.MNIST('mnist_data', train=True, download=True,
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(
(0.1307,), (0.3081,))
])),
batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(
torchvision.datasets.MNIST('mnist_data/', train=False, download=True,
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(
(0.1307,), (0.3081,))
])),
batch_size=batch_size, shuffle=False)
x, y = next(iter(train_loader))
print(x.shape, y.shape, x.min(), x.max())
plot_image(x, y, 'image sample')
# 建立三层网络
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# 每一层都是wx + b
self.fc1 = nn.Linear(28*28,256) # 28*28是图片大小,256是经验决定的
self.fc2 = nn.Linear(256,64)
self.fc3 = nn.Linear(64,10) # 10代表的是维度,不是由经验决定
# 计算过程
def forward(self,x):
"""
会接收一张张图片
:param seld:
:param x: [b,1,28,28]
:return:
"""
# h1 = relu(xw1+b1)
x = F.relu(self.fc1(x)) # 第一层,前面要加激活函数relu
# h2 = relu(h1w2+b2)
x = F.relu(self.fc2(x))
# h3 = h2w3+b3
x = self.fc3(x)
return x
# 训练
net = Net()
train_loss = []
optimizer = optim.SGD(net.parameters(),lr=0.01,momentum=0.9)# 设置一个优化器
# net.parameters() [w1,b1,w2,b2,w3,b3]
for epoch in range(3):
for batch_idx,(x,y) in enumerate(train_loader):
# x [b,1.28,28] => [b,feature]
x = x.view(x.size(0),28*28)
out = net(x)
y_onehot = one_hot(y)
loss = F.mse_loss(out,y_onehot)
optimizer.zero_grad() # 清零梯度
loss.backward()# 计算梯度
optimizer.step() # 更新梯度
train_loss.append(loss.item()) # loss.item() 把loss转化为具体的数值
if batch_idx % 10 == 0:
print(epoch,batch_idx,loss.item())
# 得到比较好的 w,b
plot_curve(train_loss)
total_correct = 0
# 准确度测试
for x,y in test_loader:
x = x.view(x.size(0),28*28)
out = net(x)
pred = out.argmax(dim=1) # 返回最大值对应的索引值
correct = pred.eq(y).sum().float() # 比较预测值真实值
total_correct += correct.item() # item()转换成数值类型
total_num = len(test_loader.dataset)
acc = total_correct / total_num
print('准确率为:{}'.format(acc))
x,y = next(iter(test_loader))
out = net(x.view(x.size(0),28*28))
pred = out.argmax(dim=1)
plot_image(x,pred,'test')