目录
python导入numpy
python和pycharm区别
归一化
神经网络中卷积层和池化层的作用探究
pytorch是什么
定义多层感知器 ，卷积层，池化层，正向传播（relu：激活函数）
model.fit()参数详解
梯度下降损失函数：Adam本质上实际是RMSProp+动量
手写数字识别python代码
python导入numpy
使用python3.7
通过pycharm直接安装
python和pycharm区别
python3.7：Python语言开发工具包
pycharm：是python开发IDE，集成很多工具；
归一化
API 文档-API文档-PaddlePaddle深度学习平台
from paddle.vision.transforms import Compose, Normalize
transform = Compose([Normalize(mean=[127.5],std=[127.5],data_format='CHW')])
class paddle.vision.transforms.Normalize(mean=0.0, std=1.0, data_format='CHW' , to_rgb=False, keys=None)
- mean (int|float|list) - 用于每个通道归一化的均值。
- std (int|float|list) - 用于每个通道归一化的标准差值。
- data_format (str, optional): 数据的格式，必须为 'HWC' 或 'CHW'。 默认值: 'CHW'。
- to_rgb (bool, optional) - 是否转换为
rgb 的格式。默认值：False。 - keys (list[str]|tuple[str], optional) - 与
BaseTransform. 默认值: None。
归一化方法有两种形式，一种是把数变为（0，1）之间的小数，一种是把有量纲表达式变为无量纲表达式。主要是为了数据处理方便提出来的，把数据映射到0～1范围之内处理，更加便捷快速，应该归到数字信号处理范畴之内。
目的：
在机器学习领域中，不同评价指标（即特征向量中的不同特征就是所述的不同评价指标）往往具有不同的量纲和量纲单位，这样的情况会影响到数据分析的结果，
为了消除指标之间的量纲影响，需要进行数据标准化处理，以解决数据指标之间的可比性。原始数据经过数据标准化处理后，各指标处于同一数量级，适合进行综合对比评价。其中，最典型的就是数据的归一化处理。
简而言之，归一化的目的就是使得预处理的数据被限定在一定的范围内（比如[0,1]或者[-1,1]），从而消除奇异样本数据导致的不良影响。
Normalize-API文档-PaddlePaddle深度学习平台
神经网络中卷积层和池化层的作用探究
卷积层用于进行特征提取。
池化层用于输入的特征图进行压缩，使特征图变小，简化网络计算复杂度或进行特征压缩，提取主要特征。
卷积核大小：[1,1,1,1] 分别对应 [batch,height,width,channels]，步长：1，填充类型：SAME
池化窗口（滤波器）大小：[1,2,2,1] 分别对应 [batch,height,width,channels], 步长：2x2, 填充类型：SAME
SAME进行填充，卷积核移动步长=1时尺寸不变，移动步长=stride时卷积完毕后尺寸为 输入的尺寸/stride再向上取整。
VALID不进行填充，卷积后尺寸计算公式为 (输入尺寸 - 核尺寸)/stride + 1 再向下取整数。
如果是VALID的话，则图片经过滤波器后可能会变小。
padding的值为‘VALID’，表示边缘不填充。
pytorch是什么
PyTorch是一个开源的Python机器学习库，基于Torch，用于自然语言处理等应用程序。
2017年1月，由Facebook人工智能研究院（FAIR）基于Torch推出了PyTorch。它是一个基于Python的可续计算包，提供两个高级功能：1、具有强大的GPU加速的张量计算（如NumPy）。2、包含自动求导系统的深度神经网络。
定义多层感知器 ，卷积层，池化层，正向传播（relu：激活函数）
【PaddlePaddle】图像分类_天山钓鱼客的博客-CSDN博客_基于paddlepaddle的图像分类
# 定义多层感知器
#TODO:动态图定义多层感知器
#请在这里定义卷积网络的代码
import paddle.nn.functional as F#导入函数
class LeNetModel(paddle.nn.Layer):
def __init__(self):
super(LeNetModel, self).__init__()
# 创建卷积和池化层块，每个卷积层后面接着2x2的池化层
#卷积层L1
#class paddle.nn.Conv2D(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1,groups=1,
#padding_mode='zeros', weight_attr=None, bias_attr=None, data_format='NCHW')
#该OP是二维卷积层（convolution2d layer），根据输入、卷积核、步长（stride）、填充（padding）、空洞大小（dilations）
#一组参数计算输出特征层大小。输入和输出是NCHW或NHWC格式，其中N是批尺寸，C是通道数，H是特征高度，W是特征宽度。
#卷积核是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是卷积核高度，W是卷积核宽度。如果组数(groups)大于1，C等于输入图像通道数除以组数的结果。详情请参考UFLDL's : 卷积 。如果bias_attr不为False，卷积计算会添加偏置项。
self.conv1 = paddle.nn.Conv2D(in_channels=1,
out_channels=6,
kernel_size=5,
stride=1)
#池化层L2
self.pool1 = paddle.nn.MaxPool2D(kernel_size=2,
stride=2)
#卷积层L3
self.conv2 = paddle.nn.Conv2D(in_channels=6,
out_channels=16,
kernel_size=5,
stride=1)
#池化层L4
self.pool2 = paddle.nn.MaxPool2D(kernel_size=2,
stride=2)
#线性层L5
self.fc1=paddle.nn.Linear(256,120)
#线性层L6
self.fc2=paddle.nn.Linear(120,84)
#线性层L7
self.fc3=paddle.nn.Linear(84,10)
#正向传播过程
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.pool1(x)
x = F.relu(x)
x = self.conv2(x)
x = self.pool2(x)
x = paddle.flatten(x, start_axis=1,stop_axis=-1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
x = F.relu(x)
out = self.fc3(x)
return out
#注意：定义完成卷积的代码后，后面的代码是需要修改的！
model.fit()参数详解
# 训练保存并验证模型
model.fit(train_dataset,test_dataset,epochs=10,batch_size=64,save_dir='multilayer_perceptron',verbose=1)
- batch_size
整数
每次梯度更新的样本数。
未指定，默认为32 - epochs
整数
训练模型迭代次数 - verbose
日志展示，整数
0:为不在标准输出流输出日志信息
1:显示进度条
2:每个epoch输出一行记录
梯度下降损失函数：Adam本质上实际是RMSProp+动量
from paddle.metric import Accuracy
# 用Model封装模型
model = paddle.Model(LeNetModel())
# TODO:定义损失函数
optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
# TODO：配置模型
手写数字识别python代码
# This is a sample Python script.
# Press Shift+F10 to execute it or replace it with your code.
# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.
def print_hi(name):
# Use a breakpoint in the code line below to debug your script.
print(f'Hi, {name}') # Press Ctrl+F8 to toggle the breakpoint.
# Press the green button in the gutter to run the script.
if __name__ == '__main__':
print_hi('PyCharm')
# See PyCharm help at https://www.jetbrains.com/help/pycharm/
print("123")
import paddle
from paddle.nn import Linear
import paddle.nn.functional as F
import os
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
# 定义mnist数据识别网络结构，同房价预测网络
class MNIST(paddle.nn.Layer):
def __init__(self):
super(MNIST, self).__init__()
# 定义一层全连接层，输出维度是1
self.fc = paddle.nn.Linear(in_features=784, out_features=1)
# 定义网络结构的前向计算过程
def forward(self, inputs):
outputs = self.fc(inputs)
return outputs
# 声明网络结构
model = MNIST()
def train(model):
# 启动训练模式
model.train()
# 加载训练集 batch_size 设为 16
train_loader = paddle.io.DataLoader(paddle.vision.datasets.MNIST(mode='train'),
batch_size=16,
shuffle=True)
# 定义优化器，使用随机梯度下降SGD优化器，学习率设置为0.001
opt = paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters())
# 图像归一化函数，将数据范围为[0, 255]的图像归一化到[0, 1]
def norm_img(img):
# 验证传入数据格式是否正确，img的shape为[batch_size, 28, 28]
assert len(img.shape) == 3
batch_size, img_h, img_w = img.shape[0], img.shape[1], img.shape[2]
# 归一化图像数据
img = img / 255
# 将图像形式reshape为[batch_size, 784]
img = paddle.reshape(img, [batch_size, img_h * img_w])
return img
# 确保从paddle.vision.datasets.MNIST中加载的图像数据是np.ndarray类型
paddle.vision.set_image_backend('cv2')
# 声明网络结构
model = MNIST()
def train(model):
# 启动训练模式
model.train()
# 加载训练集 batch_size 设为 16
train_loader = paddle.io.DataLoader(paddle.vision.datasets.MNIST(mode='train'),
batch_size=16,
shuffle=True)
# 定义优化器，使用随机梯度下降SGD优化器，学习率设置为0.001
opt = paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters())
EPOCH_NUM = 10
for epoch in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
images = norm_img(data[0]).astype('float32')
labels = data[1].astype('float32')
# 前向计算的过程
predicts = model(images)
# 计算损失
loss = F.square_error_cost(predicts, labels)
avg_loss = paddle.mean(loss)
# 每训练了1000批次的数据，打印下当前Loss的情况
if batch_id % 9000 == 0:
print("epoch_id: {}, batch_id: {}, loss is: {}".format(epoch, batch_id, avg_loss.numpy()))
# 后向传播，更新参数的过程
avg_loss.backward()
opt.step()
opt.clear_grad()
train(model)
paddle.save(model.state_dict(), './mnist.pdparams')
img_path = './work/1.png'
# 读取原始图像并显示
im = Image.open('./work/img.png')
plt.imshow(im)
plt.show()
# 将原始图像转为灰度图
im = im.convert('L')
print('原始图像shape: ', np.array(im).shape)
# 使用Image.ANTIALIAS方式采样原始图片
im = im.resize((28, 28), Image.ANTIALIAS)
plt.imshow(im)
plt.show()
print("采样后图片shape: ", np.array(im).shape)
# 读取一张本地的样例图片，转变成模型输入的格式
def load_image(img_path):
# 从img_path中读取图像，并转为灰度图
im = Image.open(img_path).convert('L')
# print(np.array(im))
im = im.resize((28, 28), Image.ANTIALIAS)
im = np.array(im).reshape(1, -1).astype(np.float32)
# 图像归一化，保持和数据集的数据范围一致
im = 1 - im / 255
return im
# 定义预测过程
model = MNIST()
params_file_path = 'mnist.pdparams'
img_path = './work/3.png'
# 加载模型参数
param_dict = paddle.load(params_file_path)
model.load_dict(param_dict)
# 灌入数据
model.eval（)
tensor_img = load_image(img_path)
result = model(paddle.to_tensor(tensor_img))
print('result', result)
# 预测输出取整，即为预测的数字，打印结果
\
