【一些自救】没有什么用的神经网络学习笔记（还没写完）

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

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

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

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

*以下均来自《深度学习入门——基于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

posted @ 2022-11-27 14:32 莳萝萝阅读(18) 评论(0) 编辑收藏举报

刷新页面返回顶部

莳萝萝

这里是个单机玩家的博客，发现问题建议私聊，在评论说什么都你对

【一些自救】没有什么用的神经网络学习笔记（还没写完）

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

Python部分

numpy

matplotlib

感知机

神经网络

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

sigmoid函数：

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

输出层的设计

神经网络的学习

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

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

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

epoch：

误差反向传播法

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

链式法则原理：

反向传播：

pytorch学习笔记

基本概念学习

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

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

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

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

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

公告

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

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

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

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