标签：函数 nn 自救 笔记 神经网络 np progress 512 True

即将面临例训而什么也不会的菜鸡惊恐

看书发现看到下一章忘记上一章，于是写点笔记拯救什么也不会的自己

或许能对你有些帮助，如果没有，这太正常了，忽略它吧

---

 

神经网络与卷积神经网络学习笔记

*以下均来自《深度学习入门——基于Python的理论与实践》

Python部分

记录一些常忘但有用的操作

关闭Python解释器时：Windows的情况下输入Ctrl-Z，然后按Enter键

Python脚本文件：将 Python程序保存为文件，然后（集中地）运行这个文件

使用：打开终端（win+r，输入cmd回车，利用cd等命令行指令（）移至文件所在位置，输入python xx.py）,就可以执行这个文件了

numpy

要生成NumPy数组，需要使用np.array()方法。np.array()接收Python 列表作为参数，生成NumPy数组（numpy.ndarray）。

NumPy数组（np.array）可以生成N维数组，数学上将一维数组称为向量， 将二维数组称为矩阵。另外，可以将一般化之后的向量或矩阵等统 称为张量（tensor）。

NumPy中，形状不同的数组之间也可以进行运算。将标量扩展成形状相同的数组再进行计算，这个巧妙 的功能称为广播（broadcast）。

对NumPy数组使用不等号运算符等（上例中是X > 15）,结果会得到一个 布尔型的数组。上例中就是使用这个布尔型数组取出了数组的各个元素（取 出True对应的元素）。

>>> X > 15
array([ True, True, False, True, False, False], dtype=bool)
>>> X[X>15]
array([51, 55, 19])

 

matplotlib

import matplotlib.pyplot as plt
from matplotlib.image import imread
img = imread('lena.png') # 读入图像（设定合适的路径！）(即将文件名更改为该文件路径如"D:\个人兴趣爱好\（推）\N241UUZlUEhZcFpZTjM0eEtJR0FCeDk4RjJYSVNnMzdGRk9rMWp5ZGRlRWpuS3B2b010TVFnPT0.jpg")
plt.imshow(img)
plt.show()

*读入图片与展示图片（好像是实验课作业先不管）

感知机

*感知机的实现——含有权重与偏置——与门

def AND(x1, x2):
 x = np.array([x1, x2])
 w = np.array([0.5, 0.5])
 b = -0.7
 tmp = np.sum(w*x) + b
 if tmp <= 0:
 return 0
 else:
 return 1

权重w1和w2是控制输入信号的重要性的参数

偏置是调 整神经元被激活的容易程度（输出信号为1的程度）的参数

实现与门与非门时仅权重与偏置不同，采用的权重与偏置满足真值表即可

感知机的局限性就在于它只能表示由一条直线分割的空间。

因此不可表示异或门。多层感知机（叠加了多层的感知机）可解决此问题

神经网络

激活函数：会将输入信号的总和转换为输出信号，作用在于决定如何来激活输入信号的总和。

阶跃函数：以阈值为界，一旦输入超过阈值，就切换输出。

Python代码实现：

def step_function(x):
 y = x > 0 # x>0 会将数组每个元素进行不等号运算，生成一个布尔型数组（y）
 return y.astype(np.int) # y通过astype方法转换为int型数组形式

 

sigmoid函数：

 

神经网络中用sigmoid函数作为激活函数，进行信号的转换，

 

 Python代码实现：

def sigmoid(x): 
　　return 1 / (1 + np.exp(-x)) 

 

比较：sigmoid函数的平滑性对神经网络的学习具有重要意义

共同点：两者均为非线性函数，神经网络的激活函数必须使用非线性函数。

ReLU函数：在输入大于0时，直接输出该值；在输入小于等于0时，输 出0（图3-9）

——Python实验课作业之一，不愿再提

 

 

Python代码实现：

def relu(x):
 return np.maximum(0, x)

 

 

 三层神经网络代码实现

#第一层的加权，输入信号x，权重w1，偏置b1
X = np.array([1.0, 0.5])
W1 = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
B1 = np.array([0.1, 0.2, 0.3])
print(W1.shape) # (2, 3)
print(X.shape) # (2,)
print(B1.shape) # (3,)
A1 = np.dot(X, W1) + B1
#a1表示隐藏层的加权和（加权信号和偏置的总和），被激活函数转换后的信号用z表示
Z1 = sigmoid(A1)
print(A1) # [0.3, 0.7, 1.1]
print(Z1) # [0.57444252, 0.66818777, 0.75026011]
# 实现第一层到第二层的信号传递
W2 = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
B2 = np.array([0.1, 0.2])
print(Z1.shape) # (3,)
print(W2.shape) # (3, 2)
print(B2.shape) # (2,)
A2 = np.dot(Z1, W2) + B2
Z2 = sigmoid(A2)
#第二层到输出层的信号传递
def identity_function(x): # 恒等函数，作为输出层的激活函数，将输入按原样输出
 return x
W3 = np.array([[0.1, 0.3], [0.2, 0.4]])
B3 = np.array([0.1, 0.2])
A3 = np.dot(Z2, W3) + B3
Y = identity_function(A3) # 或者Y = A3

view code 书作者整理代码 

输出层的设计

 

 恒等函数： 一般用于回归问题（根据某个输入预测一个（连续的） 数值的问题）

恒等函数会将输入按原样输出，对于输入的信息，不加以任何改动地直 接输出。

softmax函数：一般用于分类问题（是数 据属于哪一个类别的问题）

 

 * 输出层共有n个神经元，计算第k个神经元的输出yk

Python代码实现

def softmax(a):
 exp_a = np.exp(a)
 sum_exp_a = np.sum(exp_a)
 y = exp_a / sum_exp_a
 return y

 

注意事项：数据溢出。指数函数的运算会使值变得极大，进而难以计算，会出现溢出

改进：

 

 这里的C  可以使用任何值，但是为了防 止溢出，一般会使用输入信号中的最大值。

综上，改进后的代码实现：

def softmax(a):
 c = np.max(a)
 exp_a = np.exp(a - c) # 溢出对策
 sum_exp_a = np.sum(exp_a)
 y = exp_a / sum_exp_a
 return y

softmax函数的输出是0.0到1.0之间的实数。并且，softmax 函数的输出值的总和是1。输出总和为1是softmax函数的一个重要性质。正 因为有了这个性质，我们才可以把softmax函数的输出解释为“概率”。

即便使用了softmax函数，各个元素之间的大小关 系也不会改变

一般而言，神经网络只把输出值最大的神经元所对应的类别作为识别结果。

神经网络在进行分类时，输出层的softmax函数可以省略。在

输出层的神经元数量需要根据待解决的问题来决定。对于分类问题，输 出层的神经元数量一般设定为类别的数量。

实例：手写数字识别

假设学习已经全部结束，我们使用学习到的参 数，先实现神经网络的“推理处理”。这个推理处理也称为神经网络的前向 传播（forward propagation）

Python有 pickle这个便利的功能。这个功能可以将程序运行中的对 象保存为文件。如果加载保存过的 pickle文件，可以立刻复原之前 程序运行中的对象。用于读入MNIST数据集的load_mnist()函数内 部也使用了 pickle功能（在第 2次及以后读入时）。利用 pickle功能， 可以高效地完成MNIST数据的准备工作。

神经网络的推理处理的代码实现

def get_data():
 (x_train, t_train), (x_test, t_test) = \
 load_mnist(normalize=True, flatten=True, one_hot_label=False)
 return x_test, t_test
def init_network():
 with open("sample_weight.pkl", 'rb') as f:
 network = pickle.load(f)
 return network
def predict(network, x):
 W1, W2, W3 = network['W1'], network['W2'], network['W3']
 b1, b2, b3 = network['b1'], network['b2'], network['b3']
 a1 = np.dot(x, W1) + b1
 z1 = sigmoid(a1)
 a2 = np.dot(z1, W2) + b2
 z2 = sigmoid(a2)
 a3 = np.dot(z2, W3) + b3
 y = softmax(a3)
 return y

View Code

 

 用这3 个函数（获取数据，读入保存在pickle文件中的学习到的权重参数，预测函数）来实现神经网络的推理处理。然后，评价它的识别精度（accuracy）， 即能在多大程度上正确分类。

x, t = get_data()
network = init_network()
accuracy_cnt = 0
for i in range(len(x)):
 y = predict(network, x[i])
 p = np.argmax(y) # 获取概率最高的元素的索引
 if p == t[i]:
 accuracy_cnt += 1
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))

View Code

 

正规化：把数据限定到某 个范围内的处理

预处理：对神经网络的输入数据 进行某种既定的转换

批处理：打包式的输入数据，可以大幅缩短每张图像的处理时间

基于批处理的代码实现：

x, t = get_data()
network = init_network()
batch_size = 100 # 批数量
accuracy_cnt = 0
for i in range(0, len(x), batch_size):
 x_batch = x[i:i+batch_size] #从输入数据中抽出批数据，取出从第i个到第i+batch_n个之间的数据
 y_batch = predict(network, x_batch)
 p = np.argmax(y_batch, axis=1) # 获取值最大的元素的索引
 accuracy_cnt += np.sum(p == t[i:i+batch_size])
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))

神经网络中使用的是平滑变化的sigmoid 函数，而感知机中使用的是信号急剧变化的阶跃函数

神经网络的学习

利用数据解决识别问题：

一种方案是，先从图像中提取特征量，再用机器学习技术学习这些特征量的模式。这里所说的“特征量”是指可以从输入数据（输入图像）中准确地提取本质数据（重要的数据）的转换器。图像的特征量通常表示为向量的形式。在计算机视觉领域，常用的特征量包括 SIFT、SURF和HOG等。使用这些特征量将图像数据转换为向量，然后对转换后的向量使用机器学习中的SVM、KNN等分类器进行学习。

注：即使使用特征量和机器学习的方法，也需要针对 不同的问题人工考虑合适的特征量。

 

 

 机器学习：使用训练数据进行学习，寻找最优的参数；然后，使用测试 数据评价训练得到的模型的实际能力。为了正确评价模型的泛化能力（处理未被观察过的数据（不包含在训练数据中的数据）的 能力），就必须划分训练数据和测试数据。获得泛化能力是机器学习的最终目标。

过拟合：只对某个数据集过度拟合的状态

 

损失函数：神经网络以某个指标为线索寻找最优权重参数。神经网络的学习中 所用的指标，一般用均方误差和交叉熵误差

均方误差：yk是表示神经网络的输出，tk表示监督数据，k表示数据的维数

 

 

 one-hot表示:将正确解标签表示为1，其他标签表示为0的表示方法

均方误差会计算神经网络的输出和正确解监督数据的 各个元素之差的平方，再求总和

def mean_squared_error(y, t):
 return 0.5 * np.sum((y-t)**2)

 

交叉熵误差:yk是神经网络的输出，tk是 正确解标签

 

 

 交叉熵误差的值是由正确解标签所对应的输出结果决定的

def cross_entropy_error(y, t):
 delta = 1e-7
 return -np.sum(t * np.log(y + delta))

当出现np.log(0)时，np.log(0)会变为负无限大 的-inf，这样一来就会导致后续计算无法进行。作为保护性对策，添加一个 微小值可以防止负无限大的发生。

mini-batch学习：我们从全部数据中选出一部分，作为全部数据的“近 似”。神经网络的学习也是从训练数据中选出一批数据（称为mini-batch,小 批量），然后对每个mini-batch进行学习。比如，从60000个训练数据中随机 选择100笔，再用这100笔数据进行学习。

损失函数的意义：假设有一个神经网络，现在我们来关注这个神经网络中的某一个权重参 数。此时，对该权重参数的损失函数求导，表示的是“如果稍微改变这个权 重参数的值，损失函数的值会如何变化”。如果导数的值为负，通过使该权 重参数向正方向改变，可以减小损失函数的值；反过来，如果导数的值为正， 则通过使该权重参数向负方向改变，可以减小损失函数的值。不过，当导数 的值为0时，无论权重参数向哪个方向变化，损失函数的值都不会改变，此 时该权重参数的更新会停在此处。如果以 识别精度为指标，则参数的导数在绝大多数地方都会变为0。

一些高等数学知识储备

导数，数值微分，偏导数（待补充）

梯度：这样的由全部变量的偏导数汇总 而成的向量，梯度指示的方向 是各点处的函数值减小最多的方向 

Python实现：

def numerical_gradient(f, x):
 h = 1e-4 # 0.0001
 grad = np.zeros_like(x) # 生成和x形状相同的数组
 for idx in range(x.size):
 tmp_val = x[idx]
 # f(x+h)的计算
 x[idx] = tmp_val + h
 fxh1 = f(x)
 # f(x-h)的计算
 x[idx] = tmp_val - h
 fxh2 = f(x)
 grad[idx] = (fxh1 - fxh2) / (2*h)
 x[idx] = tmp_val # 还原值
 return grad

View Code

 

梯度法：巧妙地使用梯度来寻找函数最小值 （或者尽可能小的值）的方法。在梯度法中，函数的取值从当前位置沿着梯 度方向前进一定距离，然后在新的地方重新求梯度，再沿着新梯度方向前进， 如此反复，不断地沿梯度方向前进。像这样，通过不断地沿梯度方向前进， 逐渐减小函数值的过程。寻找最小值的梯度法称为梯度下降法，寻找最大值的梯度法称为梯度上升法。

 

 

 η表示更新量，在神经网络的学习中，称为学习率（learning rate）。学习率决定在一次学习中，应该学习多少，以及在多大程度上更新参数。学习率需要事先确定为某个值。

Python实现：

def gradient_descent(f, init_x, lr=0.01, step_num=100):
 x = init_x
 for i in range(step_num):
 grad = numerical_gradient(f, x)
 x -= lr * grad
 return x

 

参数f是要进行最优化的函数，init_x是初始值，lr是学习率learning rate，step_num是梯度法的重复次数。numerical_gradient(f,x)会求函数的 梯度，用该梯度乘以学习率得到的值进行更新操作，由step_num指定重复的 次数。 使用这个函数可以求函数的极小值，顺利的话，还可以求函数的最小值。

学习率这样的参数称为超参数。这是一种和神经网络的参数（权重 和偏置）性质不同的参数。

相对于神经网络的权重参数是通过训练 数据和学习算法自动获得的，学习率这样的超参数则是人工设定的。 一般来说，超参数需要尝试多个值，以便找到一种可以使学习顺利 进行的设定。

神经网络的学习——随机梯度下降法（SGD）

前提 神经网络存在合适的权重和偏置，调整权重和偏置以便拟合训练数据的 过程称为“学习”。

神经网络的学习分成下面4个步骤。

步骤1（mini-batch） 从训练数据中随机选出一部分数据，这部分数据称为mini-batch。我们 的目标是减小mini-batch的损失函数的值。

步骤2（计算梯度） 为了减小mini-batch的损失函数的值，需要求出各个权重参数的梯度。 梯度表示损失函数的值减小最多的方向。

步骤3（更新参数） 将权重参数沿梯度方向进行微小更新。 

步骤4（重复） 重复步骤1、步骤2、步骤3

epoch：

一个单位。一个 epoch表示学习中所有训练数据均被使用过 一次时的更新次数。比如，对于 10000笔训练数据，用大小为 100 笔数据的mini-batch进行学习时，重复随机梯度下降法 100次，所 有的训练数据就都被“看过”了A。此时，100次就是一个 epoch。

 

误差反向传播法

能够高效计算权重参数的梯度，两种理解方法：一种是基于数学式； 另一种是基于计算图（computational graph）

用计算图解题的情况下，需要按如下流程进行。 1.构建计算图。 2.在计算图上，从左向右进行计算。

正向传播是从计算图出发点到结束点的传播。，反向传播是从计算图从右向左的传播

计算图优点：可以集中精力于局部计算，图可以将中间的计算结果全部保存起来，可以通过反 向传播高效计算导数

　　　　　　可以通过正向传播和反向传 播高效地计算各个变量的导数值

链式法则原理：

如果某个函数由复合函数表示，则该复合函数的导数可以用构成复 合函数的各个函数的导数的乘积表示。

反向传播：

*

pytorch学习笔记

基本概念学习

总而言之我为它安装前后安了又卸三次才成功……做好准备，这个麻烦死人

*

VGG代码注释：

  1 # 引入相关的库
  2 from torchvision.models import vgg
  3 
  4 import torch
  5 import torch.nn as nn
  6 
  7 try:
  8     from torch.hub import load_state_dict_from_url
  9 except ImportError:
 10     from torch.utils.model_zoo import load_url as load_state_dict_from_url
 11 
 12 # 定义了一个可以从外部引用的字符串列表：
 13 __all__ = [
 14     'VGG', 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn',
 15     'vgg19_bn', 'vgg19',
 16 ]
 17 
 18 # 预训练模型的下载地址：
 19 model_urls = {
 20     'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
 21     'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
 22     'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
 23     'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth',
 24     'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',
 25     'vgg13_bn': 'https://download.pytorch.org/models/vgg13_bn-abd245e5.pth',
 26     'vgg16_bn': 'https://download.pytorch.org/models/vgg16_bn-6c64b313.pth',
 27     'vgg19_bn': 'https://download.pytorch.org/models/vgg19_bn-c79401a0.pth',
 28 }
 29 
 30 # 定义VGG类（继承nn.Module类）：
 31 class VGG(nn.Module):
 32 
 33     def __init__(self, features, num_classes=1000, init_weights=True):
 34         # super（）允许您避免显式地引用基类，主要优势在于多重继承。
 35         super(VGG, self).__init__()
 36         self.features = features
 37         # nn.AdaptiveAvgPool2d((7, 7)):
 38         # 自适应平均池化，出来特征图的size为7X7。以应对不同大小的图像尺寸。
 39         # 简而言之，为了适应输入和输出的大小，自动调整池化模板的大小。
 40         self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
 41         # 自定义分类器
 42         self.classifier = nn.Sequential(
 43             nn.Linear(512 * 7 * 7, 4096),
 44             nn.ReLU(True),
 45             nn.Dropout(),
 46             nn.Linear(4096, 4096),
 47             nn.ReLU(True),
 48             nn.Dropout(),
 49             nn.Linear(4096, num_classes),
 50         )
 51         # 是否需要权重初始化
 52         if init_weights:
 53             self._initialize_weights()
 54 
 55     # 前向传播
 56     def forward(self, x):
 57         x = self.features(x)
 58         x = self.avgpool(x)
 59         x = torch.flatten(x, 1)
 60         # 展平一个连续范围的维度，输出类型为Tensor
 61         #torch.flatten(input, start_dim=0, end_dim=-1) → Tensor
 62         # 参数说明：input (Tensor) – 输入为Tensor
 63         # start_dim (int) – 展平的开始维度
 64         # end_dim (int) – 展平的最后维度
 65         x = self.classifier(x)
 66         return x
 67 
 68     #定义权重初始化函数
 69     def _initialize_weights(self):
 70         for m in self.modules():
 71             if isinstance(m, nn.Conv2d):
 72                 nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
 73                 if m.bias is not None:
 74                     nn.init.constant_(m.bias, 0)
 75             elif isinstance(m, nn.BatchNorm2d):
 76                 nn.init.constant_(m.weight, 1)
 77                 nn.init.constant_(m.bias, 0)
 78             elif isinstance(m, nn.Linear):
 79                 nn.init.normal_(m.weight, 0, 0.01)
 80                 nn.init.constant_(m.bias, 0)
 81 
 82 # 定义层生成函数：
 83 # 'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M']
 84 def make_layers(cfg, batch_norm=False):
 85     layers = []
 86     in_channels = 3
 87     for v in cfg:
 88         if v == 'M':
 89             layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
 90         else:
 91             conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
 92             if batch_norm:
 93                 layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
 94             else:
 95                 layers += [conv2d, nn.ReLU(inplace=True)]
 96             in_channels = v
 97     return nn.Sequential(*layers)
 98 
 99 
100 cfgs = {
101     'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
102     'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
103     'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
104     'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
105 }
106 
107 # 定义模型生成函数：
108 def _vgg(arch, cfg, batch_norm, pretrained, progress, **kwargs):
109     if pretrained:
110         kwargs['init_weights'] = False
111     model = VGG(make_layers(cfgs[cfg], batch_norm=batch_norm), **kwargs)
112     if pretrained:
113         state_dict = load_state_dict_from_url(model_urls[arch],
114                                               progress=progress)
115         model.load_state_dict(state_dict)
116     return model
117 
118 
119 def vgg11(pretrained=False, progress=True, **kwargs):
120     r"""VGG 11-layer model (configuration "A") from
121     `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
122 
123     Args:
124         pretrained (bool): If True, returns a model pre-trained on ImageNet
125         progress (bool): If True, displays a progress bar of the download to stderr
126     """
127     return _vgg('vgg11', 'A', False, pretrained, progress, **kwargs)
128 
129 
130 def vgg11_bn(pretrained=False, progress=True, **kwargs):
131     r"""VGG 11-layer model (configuration "A") with batch normalization
132     `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
133 
134     Args:
135         pretrained (bool): If True, returns a model pre-trained on ImageNet
136         progress (bool): If True, displays a progress bar of the download to stderr
137     """
138     return _vgg('vgg11_bn', 'A', True, pretrained, progress, **kwargs)
139 
140 
141 def vgg13(pretrained=False, progress=True, **kwargs):
142     r"""VGG 13-layer model (configuration "B")
143     `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
144 
145     Args:
146         pretrained (bool): If True, returns a model pre-trained on ImageNet
147         progress (bool): If True, displays a progress bar of the download to stderr
148     """
149     return _vgg('vgg13', 'B', False, pretrained, progress, **kwargs)
150 
151 
152 def vgg13_bn(pretrained=False, progress=True, **kwargs):
153     r"""VGG 13-layer model (configuration "B") with batch normalization
154     `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
155 
156     Args:
157         pretrained (bool): If True, returns a model pre-trained on ImageNet
158         progress (bool): If True, displays a progress bar of the download to stderr
159     """
160     return _vgg('vgg13_bn', 'B', True, pretrained, progress, **kwargs)
161 
162 
163 def vgg16(pretrained=False, progress=True, **kwargs):
164     r"""VGG 16-layer model (configuration "D")
165     `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
166 
167     Args:
168         pretrained (bool): If True, returns a model pre-trained on ImageNet
169         progress (bool): If True, displays a progress bar of the download to stderr
170     """
171     return _vgg('vgg16', 'D', False, pretrained, progress, **kwargs)
172 
173 
174 def vgg16_bn(pretrained=False, progress=True, **kwargs):
175     r"""VGG 16-layer model (configuration "D") with batch normalization
176     `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
177 
178     Args:
179         pretrained (bool): If True, returns a model pre-trained on ImageNet
180         progress (bool): If True, displays a progress bar of the download to stderr
181     """
182     return _vgg('vgg16_bn', 'D', True, pretrained, progress, **kwargs)
183 
184 
185 def vgg19(pretrained=False, progress=True, **kwargs):
186     r"""VGG 19-layer model (configuration "E")
187     `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
188 
189     Args:
190         pretrained (bool): If True, returns a model pre-trained on ImageNet
191         progress (bool): If True, displays a progress bar of the download to stderr
192     """
193     return _vgg('vgg19', 'E', False, pretrained, progress, **kwargs)
194 
195 
196 def vgg19_bn(pretrained=False, progress=True, **kwargs):
197     r"""VGG 19-layer model (configuration 'E') with batch normalization
198     `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
199 
200     Args:
201         pretrained (bool): If True, returns a model pre-trained on ImageNet
202         progress (bool): If True, displays a progress bar of the download to stderr
203     """
204     return _vgg('vgg19_bn', 'E', True, pretrained, progress, **kwargs)
205 
206 
207 if __name__ == '__main__':
208     from torchsummary import summary
209     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
210     model = vgg16().to(device)
211     print(model)
212     img = torch.rand(1, 3, 448, 448).to(device)
213     y = model(img)
214     summary(model, input_size=(3, 448, 448))

View Code

 

训练脚本（有点问题）

 

附加查阅资料：一些课堂学习知识之系统相关标准模块

• os标准模块: 各种操作系统的接口工具函数.

• sys标准模块: 包含与系统相关的参数与函数

• shutil标准模块: 高级文件操作, Shell相关工具方法.

  以上以下均摘自（复制）聪哥PPT，全标引用可以吗……

os标准模块

 在Python内运行可在终端执行的外部程序，os.system('xx')

利用os.environ获取系统信息

os.getcwd() 返回当前工作目录

os.listdir(path) 获取目录文件列表信息

os.chdir(new_path) 改变工作目录(此处new_path可以是绝对路径也可以是相对路径)

os.rename(src, dst) 重命名文件或目录，从src 到 dst

 os.remove(path) 函数用来删除一个文件

os.mkdir(path[, mode]) 创建一个目录

os.rmdir(path[, mode]) 删除一个目录

os.makedirs(path) 递归的创建目录,

参数exist_ok如果是True, 则目录已存在则不会报错.

os.removedirs(path)删除递归删除目录树

os.path.exists() 函数用来检验给出的路径是否真地存在

os.path.isfile() 和 os.path.isdir(): 函数分别检验给出的路径是一个文件还是目录

os.path.getsize(name) 获得文件大小，如果name是目录返回0L

os.path.abspath(name) 获得绝对路径

os.path.splitext() 分离文件名与扩展名

os.path.split(path) 函数返回一个路径的目录名和文件名

os.path.join(path,name) 连接目录与文件名或目录

os.path.basename(path) 返回文件名

os.path.dirname(path) 返回文件路径

os.path.isabs(path) 判断是不是绝对路径

os.path.relpath(path, start=os.curdir)¶ 获取相对路径

 sys标准模块

sys.version 获取Python开发平台的版本信息

sys.platform 返回操作系统平台名称

sys.modules 以字典形式返回系统导入的模块, 其中key是模块名，value是模块信息

sys.path 以列表形式存储Python对模块的搜索路径, 初始化时使用PYTHONPATH环境变量的值

sys.exec_prefix 返回平台独立的python文件安装的位置

sys.path.append() 为Python添加自定义模块的搜索路径

sys.argv 获取命令行参数

 sys.exit(n) 退出Python进程（退出运行程序）

shutil标准模块

shutil.copyfile( src, dst): 从源src复制到dst中去, 如果当前的dst已存在, 会被覆盖.

shutil.move( src, dst): 移动文件或重命名

shutil.copymode( src, dst): 拷贝权限模式, 目标文件dst要已存在. 只是会拷贝其权限, 其他的内容是不被拷贝的, 

shutil.copystat( src, dst): 拷贝文件状态, 权限、最后访问时间、最后修改时间

shutil.copy( src, dst): 拷贝复制一个文件到一个文件或一个目录

shutil.copy2( src, dst): 在copy上的基础上再拷贝文件最后访问时间与修改时间也复制过来了, 类似于终端上的cp –p命令

shutil.copytree( olddir, newdir, symlinks=Flase, ignore=None, copy_function=copy2) : 把olddir拷贝一份newdir. 如果参数symlinks是True,则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接

shutil.rmtree( src ) 递归删除一个目录以及目录内的所有内容

shutil.make_archive(base_name, format, root_dir) :创建压缩包并返回文件路径, 例如: zip、tar

标签：函数,nn,自救,笔记,神经网络,np,progress,512,True
From： https://www.cnblogs.com/Phantomhive/p/16929637.html