首先，感谢张团长（手动@豪哥）让我接触到paddlepaddle的平台，并且经过接近一个月的学习大概入了一个小门，了解和接触到一点有关于计算机视觉、图像处理以及一些深度学习的概念，这些在接触到paddle之前我是前所未闻的，可以说带我很好的入了一个门。当然短暂的学习明显是不够的，即使课程结束了，仍然要继续努力继续学习，在这样一个氛围浓厚、资源共享的平台基础上，有效的挖掘到更多更好的资源扩充自己的见解，并且真切的用到之后可以做的项目中去。

其次是我关于图像分类基础的几类模型的整理（包括源代码和结果实例）

#一、线性回归模型

#1.自定义随机样本

import numpy
num_inputs = 2
num_examples = 500
true_w=[1.2,2.5]
true_b=6.8
features = numpy.random.normal(0,1,(num_examples,num_inputs)).astype('float32')
labels = features[:,0]*true_w[0]+features[:,1]*true_w[1]+true_b
labels = labels+numpy.random.normal(0,0.001,labels.shape[0])
labels = labels.astype('float32')
labels = numpy.expand_dims(labels,axis=-1) #最后添加一个维度

#2.构建线性回归模型
import paddle
train_data = paddle.to_tensor(features) #数据转型
y_true = paddle.to_tensor(labels)
model = paddle.nn.Linear(in_features=2, out_features=1) #两个输入一个输出

#3.构建优化器和损失函数
sgd_optmiser = paddle.optimizer.SGD(learning_rate=0.001,parameters=model.parameters()) #优化器采用梯度下降法 学习率为0.001，可变参数对应model的参数

mse_loss = paddle.nn.MSELoss() #使用均方损失函数for i in range(5000):
    y_predict = model(train_data)
    loss = mse_loss(y_predict,y_true)
    loss.backward()
    sgd_optmiser.step() #下一步
    sgd_optmiser.clear_grad() #计数器清零 以上两条很关键

print(model.weight.numpy()) #学习到的权重
print(model.bias.numpy()) #学习到的参数
print(loss.numpy()) #损失值
#与初始值对比，可以发现相差不大，学习的挺好
#注意的是，线性回归用的是连续性数据，离散型数据可以使用softmax分类器

#二、基于softmax的手写数字识别分类（最基础的版本了，等价于Hello World的阉割版）
#1.调用数据集。手写数字数据集来自MNIST数据集 train 60000+,test 10000+,样本由28 * 28像素组成的矩阵，取值在0~255 之间
import paddle
train_dataset = paddle.vision.datasets.MNIST(mode="train",backend="cv2") #训练数据集
test_dataset = paddle.vision.datasets.MNIST(mode="test",backend="cv2") #测试数据集
#小例子查看数据集中的数据
import matplotlib.pyplot as plt

train_data0,train_label0 = train_dataset[1][0],train_dataset[1][1] #对应数据
train_data0 = train_data0.reshape([28,28]) #将数据以28 * 28 的形式展现出
plt.figure(figsize=(10,10)) #以10英寸显示窗口
plt.imshow(train_data0,cmap=plt.cm.binary) #可视化操作


linear = paddle.nn.Sequential(
    paddle.nn.Flatten(), #“压扁”操作
    paddle.nn.Linear(784,10) #函数输入784输出10
)
model=paddle.Model(linear)
model.prepare(paddle.optimizer.Adam(learning_rate=0.001,parameters=model.parameters()),
            paddle.nn.CrossEntropyLoss(),#交叉熵损失函数。配合线性模型，即可构成softmax分类器
            paddle.metric.Accuracy(topk=(1,2)) #精确度
            )
model.fit(train_dataset,epochs=3,batch_size=64,verbose=1)
model.evaluate(test_dataset,batch_size=64,verbose=1)

#三、基于多层感知机的手写数字识别分类
import paddle
import paddle.nn.functional as F
from paddle.vision.transforms import ToTensor

#导入数据
train_dataset=paddle.vision.datasets.MNIST(mode="train",transform=ToTensor())
val_dataset=paddle.vision.datasets.MNIST(mode="test",transform=ToTensor())

#定义模型
class MLPModel(paddle.nn.Layer): #继承
    def __init__(self): #初始化
        super(MLPModel,self).__init__()
        self.flatten = paddle.nn.Flatten()
        self.hidden = paddle.nn.Linear(in_features=784,out_features=128)
        self.output = paddle.nn.Linear(in_features=128,out_features=10)

    def forward(self,x): #数据处理顺序
        x=self.flatten(x)
        x=self.hidden(x)
        x=F.relu(x)
        x=self.output(x)
        return x
#高阶API封装成实例
model = paddle.Model(MLPModel())

model.prepare(paddle.optimizer.Adam(parameters=model.parameters()), #优化函数
                paddle.nn.CrossEntropyLoss(), #损失函数
                paddle.metric.Accuracy()) #求解精度
model.fit(train_dataset,
            epochs=5,
            batch_size=64,
            verbose=1)

model.evaluate(val_dataset,verbose=1) #验证数据集评估

 
    
#四、卷积网络LeNet-5来实现数字识别
#LeNet-5 对应七个隐藏层：卷积L1->池化L2->卷积L3->池化L4->线性L5->线性L6->线性L7

import paddle
import paddle.nn.functional as F
from paddle.vision.transforms import Compose, ToTensor

transform = Compose([ToTensor()])
#导入CIFAR10图像数据
train_dataset=paddle.vision.datasets.Cifar10(mode="train", transform=transform)
val_dataset=paddle.vision.datasets.Cifar10(mode="test", transform=transform)
#定义模型
class LeNetModel(paddle.nn.Layer):
    def __init__(self):
        super(LeNetModel, self).__init__()
        # 创建卷积和池化层块，每个卷积层后面接着2x2的池化层
        #卷积层L1
        self.conv1 = paddle.nn.Conv2D(in_channels=3, #CIFAR10数据集有3个颜色通道
                                      out_channels=6,
                                      kernel_size=5,
                                      stride=1,
                                      data_format='NCHW')
        #池化层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,
                                      data_format='NCHW')
        #池化层L4
        self.pool2 = paddle.nn.MaxPool2D(kernel_size=2,
                                         stride=2)
        #线性层L5
        self.fc1=paddle.nn.Linear(400,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=paddle.Model(LeNetModel())

model.prepare(paddle.optimizer.Adam(parameters=model.parameters()),
              paddle.nn.CrossEntropyLoss(),
              paddle.metric.Accuracy())

model.fit(train_dataset,
          epochs=5,
          batch_size=64,
          verbose=1)

model.evaluate(val_dataset,verbose=1)