即将面临例训而什么也不会的菜鸡惊恐
看书发现看到下一章忘记上一章,于是写点笔记拯救什么也不会的自己
或许能对你有些帮助,如果没有,这太正常了,忽略它吧
神经网络与卷积神经网络学习笔记
*以下均来自《深度学习入门——基于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)
三层神经网络代码实现
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#第一层的加权,输入信号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 = A3view code
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
输出层的设计
恒等函数: 一般用于回归问题(根据某个输入预测一个(连续的) 数值的问题)
恒等函数会将输入按原样输出,对于输入的信息,不加以任何改动地直 接输出。
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数据的准备工作。
神经网络的推理处理的代码实现
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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 yView Code
用这3 个函数(获取数据,读入保存在pickle文件中的学习到的权重参数,预测函数)来实现神经网络的推理处理。然后,评价它的识别精度(accuracy), 即能在多大程度上正确分类。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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实现:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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 gradView 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代码注释:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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标准模块
标签:函数,nn,自救,笔记,神经网络,np,progress,512,True From: https://www.cnblogs.com/Phantomhive/p/16929637.htmlshutil.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