Pytorch

2017年推出《Attention is All You Need》以来，transformers 曾经成为自然语言解决(NLP)的最新技术。2021年，《An Image is Worth 16x16 Words》，胜利地将transformers 用于计算机视觉工作。从那时起，许多基于transformers的计算机视觉体系结构被提出。 本文将深入探讨注意力层在计算机视觉环境中的工作原理。咱们将探讨单头注意力和多头注意力。它包含注意力层的代码，以及根底数学的概念解释。 在NLP利用中，注意力通常被形容为句子中单词(标记)之间的关系。而在计算机视觉应用程序中，注意力关注图像中patches (标记)之间的关系。 有多种办法能够将图像合成为一系列标记。原始的ViT²将图像宰割成小块，而后将小块平摊成标记。《token -to- token ViT》³开发了一种更简单的从图像创立标记的办法。 点积注意力《Attention is All You Need》中定义的点积(相当于乘法)注意力是目前咱们最常见也是最简略的一种中注意力机制，他的代码实现非常简单： classAttention(nn.Module): def__init__(self, dim: int, chan: int, num_heads: int=1, qkv_bias: bool=False, qk_scale: NoneFloat=None): """ Attention Module Args: dim (int): input size of a single token chan (int): resulting size of a single token (channels) num_heads(int): number of attention heads in MSA qkv_bias (bool): determines if the qkv layer learns an addative bias qk_scale (NoneFloat): value to scale the queries and keys by; if None, queries and keys are scaled by ``head_dim ** -0.5`` """ super().__init__() ## Define Constants self.num_heads=num_heads self.chan=chan self.head_dim=self.chan//self.num_heads self.scale=qk_scaleorself.head_dim**-0.5 assertself.chan%self.num_heads==0, '"Chan" must be evenly divisible by "num_heads".' ## Define Layers self.qkv=nn.Linear(dim, chan*3, bias=qkv_bias) #### Each token gets projected from starting length (dim) to channel length (chan) 3 times (for each Q, K, V) self.proj=nn.Linear(chan, chan) defforward(self, x): B, N, C=x.shape ## Dimensions: (batch, num_tokens, token_len) ## Calcuate QKVs qkv=self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4) #### Dimensions: (3, batch, heads, num_tokens, chan/num_heads = head_dim) q, k, v=qkv[0], qkv[1], qkv[2] ## Calculate Attention attn= (q*self.scale) @k.transpose(-2, -1) attn=attn.softmax(dim=-1) #### Dimensions: (batch, heads, num_tokens, num_tokens) ## Attention Layer x= (attn@v).transpose(1, 2).reshape(B, N, self.chan) #### Dimensions: (batch, heads, num_tokens, chan) ## Projection Layers x=self.proj(x) ## Skip Connection Layer v=v.transpose(1, 2).reshape(B, N, self.chan) x=v+x #### Because the original x has different size with current x, use v to do skip connection returnx单头注意力对于单个注意力头，让咱们逐渐理解向前传递每一个patch，应用7 * 7=49作为起始patch大小（因为这是T2T-ViT模型中的起始标记大小）。通道数64这也是T2T-ViT的默认值。而后假如有100标记，并且应用批大小为13进行前向流传（抉择这两个数值是为了不会与任何其余参数混同）。 ...

曾经装置Pytorch的cuda版本，但还是调用的cpu，无奈调用gpu。用上面的代码测试，显示为false。 import torchtorch.cuda.is_available() # cuda是否可用torch.version.cuda # cuda版本torch.backends.cudnn.is_available() # cudnn是否可用torch.backends.cudnn.version() # cudnn版本，输入后果看不懂在这里没有找到cudnn的包，应该是须要装置nvidia的cudnn包。1.下载对应版本的cudnn包我的pytorch cuda版本为11.7，须要下载对应cuda11.x的cudnn软件，下载地址为：https://developer.nvidia.com/rdp/cudnn-archive#a-collapse805-111抉择windows安装包，下载安装。 一文讲清楚CUDA、CUDA toolkit、CUDNN、NVCC关系https://blog.csdn.net/qq_41094058/article/details/116207333显卡，显卡驱动,nvcc, cuda driver,cudatoolkit,cudnn到底是什么？https://zhuanlan.zhihu.com/p/91334380 window11零碎CUDA、cuDNN 装置以及环境变量配置http://www.rply.cn/news/113428.html Windows10中CUDA cundnn pytorch环境搭建记录https://blog.csdn.net/weixin_44848751/article/details/131838248

文章和代码曾经归档至【Github仓库：https://github.com/timerring/dive-into-AI 】或者公众号【AIShareLab】回复 pytorch教程 也可获取。模型创立与nn.Module 创立网络模型通常有2个因素： 构建子模块拼接子模块 - class LeNet(nn.Module): # 子模块创立    def __init__(self, classes):        super(LeNet, self).__init__()        self.conv1 = nn.Conv2d(3, 6, 5)        self.conv2 = nn.Conv2d(6, 16, 5)        self.fc1 = nn.Linear(16*5*5, 120)        self.fc2 = nn.Linear(120, 84)        self.fc3 = nn.Linear(84, classes) # 子模块拼接    def forward(self, x):        out = F.relu(self.conv1(x))        out = F.max_pool2d(out, 2)        out = F.relu(self.conv2(out))        out = F.max_pool2d(out, 2)        out = out.view(out.size(0), -1)        out = F.relu(self.fc1(out))        out = F.relu(self.fc2(out))        out = self.fc3(out)        return out调用net = LeNet(classes=2)创立模型时，会调用__init__()办法创立模型的子模块。 ...

文章和代码曾经归档至【Github仓库：https://github.com/timerring/dive-into-AI 】或者公众号【AIShareLab】回复 pytorch教程 也可获取。数据加强 Data Augmentation数据加强又称为数据增广，数据扩增，它是对训练集进行变换，使训练集更丰盛，从而让模型更具泛化能力。 技巧： debug console：命令输出窗的环境与以后代码调试的环境完全一致，能够对变量进行更改或者查看。 例如这里对于输出变量的shape进行了查看。 因为图片通过 transform 操作之后是 tensor，像素值在 0\~1 之间，并且标准差和方差不是失常图片的。所以定义了transform_invert()办法。性能是对 tensor 进行反标准化操作，并且把 tensor 转换为 image，不便可视化。 次要批改的是transforms.Compose代码块中的内容，其中transforms.Resize((224, 224))是把图片缩放到 (224, 224) 大小，而后再进行其余 transform 操作。 裁剪Croptransforms.CenterCroptorchvision.transforms.CenterCrop(size)性能：从图像核心裁剪图片 size ：所需裁剪图片尺寸CenterCrop：以核心裁剪，如果裁剪尺寸小于原尺寸，则显示裁剪后的局部，否则对于多出的局部填充为0的像素（即彩色）。 transforms.RandomCroptorchvision.transforms.RandomCrop(size, padding=None, pad_if_needed=False, fill=0, padding_mode='constant')性能：从图片中随机裁剪出尺寸为size 的图片，若有 padding，那么先进行 padding，再随机裁剪 size 大小的图片。 size: 裁剪大小padding: 设置填充大小 当为 a 时，上下左右均填充 a 个像素当为 (a, b) 时，左右填充 a 个像素，高低填充 b 个像素当为 (a, b, c, d) 时，左上右下别离填充 a，b，c，dpad\_if\_need: 当图片小于设置的 size，是否填充padding\_mode: constant: 像素值由 fill 设定edge: 用图像边缘的像素值进行填充reflect: 镜像填充，最初一个像素不镜像。([1,2,3,4] -> [3,2,1,2,3,4,3,2]) ...

文章和代码曾经归档至【Github仓库：https://github.com/timerring/dive-into-AI 】或者公众号【AIShareLab】回复 pytorch教程 也可获取。图像预处理 transformstransforms运行机制torchvision：计算机视觉工具包 torchvision.transforms 罕用的图像预处理办法，例如： 数据中心化数据标准化缩放裁剪旋转翻转填充噪声增加灰度变换线性变换仿射变换亮度、饱和度及对比度变换 torchvision.datasets 罕用数据集的 dataset 实现， MNIST CIFAR 10 ImageNet 等 torchvision.model 罕用的模型预训练， AlexNet VGG ResNet GoogLeNet 等 transforms运行的机制 数据标准化transforms.normalizetransforms.Normalize 标准化的含意是将数据的均值变为0，标准差变为1。 性能：逐channel 的对图像进行标准化 output = (input - mean) / std mean ：各通道的均值std ：各通道的标准差inplace ：是否原地操作对数据进行标准化后能够放慢模型的收敛。通过比拟不同的试验后果可知，一个好的数据分布更加利于模型的整体收敛。

各位Python高手，明天我要给大家介绍一个好用的库，它就是：tqdm tqdm在阿拉伯语中的意思是 "停顿"，所以这个库也被称为 "疾速停顿条"。不得不说，这个名字真的很有创意！ 让咱们设想一下，你正在运行一个耗时的数据处理工作或者训练一个简单的深度学习模型。你坐在那里，盯着屏幕，着急地期待程序实现。这种期待的苦楚，我想你我都有切身体会。这时候，有个可视化的进度条会不会让你感觉好很多呢？这就是咱们明天要举荐的 tqdm 库的性能。 tqdm 是一个 Python 疾速、可扩大的进度条工具库，它有很多长处： 易于应用：只需在 Python 循环中包裹你的迭代器，一行代码就能产生一个精美的进度条。 灵便：它能够和 for 循环、pandas dataframe的 apply 函数以及 Python 的 map 函数等等配合应用。 高效：tqdm 应用了智能算法，即便在数据流十分快的状况下，也不会拖慢你的代码速度。 让咱们看一下 tqdm 在机器学习工作中的利用示例： from tqdm import tqdmimport timefor i in tqdm(range(100)): # 假如咱们正在进行一些耗时的操作，比方训练深度学习模型 time.sleep(0.01)运行这段代码，你会看到一个动静更新的进度条。tqdm 会通知你还有多少项须要解决，预计剩余时间，以及以后的处理速度。 你会看到一个动静更新的进度条。tqdm 会通知你还有多少项须要解决，预计剩余时间，以及以后的处理速度。 100%|██████████| 100/100 [00:01<00:00, 97.31it/s]咱们持续深刻到 tqdm 的更多应用场景和用法。 01 你是否曾在下载大文件时，想要晓得下载的进度呢？tqdm 能够很好地满足你的需要。看看上面的代码： import requestsfrom tqdm import tqdmresponse = requests.get(url, stream=True) # 把stream参数设置为Truefile_size = int(response.headers['Content-Length'])chunk = 1chunk_size = 1024num_bars = int(file_size / chunk_size)with open(filename, 'wb') as fp: for chunk in tqdm(response.iter_content(chunk_size=chunk_size), total=num_bars, unit='KB', desc=filename, leave=True): fp.write(chunk)在下面的代码中，咱们首先获取到要下载文件的大小。而后，咱们在 tqdm 中设置总的进度条数目为文件大小除以每个进度条代表的字节数。这样，当咱们下载每一个字节块并写入文件时，tqdm 就会自动更新进度条。 ...

download：PyTorch深度学习开发医学影像端到端判断我的项目PyTorch深度学习：从入门到精通PyTorch是一个十分风行的深度学习框架，它能够帮忙钻研人员和开发者疾速地构建、训练、测试神经网络模型。本文将介绍PyTorch深度学习的基础知识，并提供一些实用的技巧和工具，以便您可能轻松地进入深度学习畛域。 什么是PyTorch？PyTorch是由Facebook公司开发的开源机器学习库，被广泛应用于自然语言解决、计算机视觉、举荐零碎等畛域。与TensorFlow等其余深度学习框架不同，PyTorch采纳动态图的形式进行计算图的构建和计算，这使得它更加易于应用和调试。 疾速入门PyTorch要开始应用PyTorch深度学习，您须要先装置PyTorch并理解一些基本概念。以下是一个简略的例子，阐明如何应用PyTorch来创立一个线性回归模型： pythonimport torchimport numpy as np 创立数据集x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168], [9.779], [6.182], [7.59], [2.167], [7.042], [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573], [3.366], [2.596], [2.53], [1.221], [2.827], [3.465], [1.65], [2.904], [1.3]], dtype=np.float32) 将数据集转换成张量x_train = torch.from_numpy(x_train)y_train = torch.from_numpy(y_train) 定义模型class LinearRegression(torch.nn.Module): def __init__(self): super(LinearRegression, self).__init__() self.linear = torch.nn.Linear(1, 1) # 输出和输入的维度都是1def forward(self, x): out = self.linear(x) return outmodel = LinearRegression() ...

图像识别算法--VGG16[TOC] 1、参考文献VGG16：[1]SIMONYAN K, ZISSERMAN A. Very Deep Convolutional Networks for Large-Scale Image Recognition[M/OL]. arXiv, 2015[2023-04-07]. http://arxiv.org/abs/1409.1556. Dropout：[2]SRIVASTAVA N, HINTON G, KRIZHEVSKY A, 等. Dropout: A Simple Way to Prevent Neural Networks from Overfitting[J]. 2、VGG16实践2.1 VGG16 长处1、应用3x3的卷积核而非7x7的卷积核 First, we incorporate three non-linear rectification layers instead of a single one, which makes the decision function more discriminative. Second, we decrease the number of parameters.也就是说VGG16一方面缩小了参数（绝对于7x7），另外一方面通过3非线性层，更加具备非线性表达能力 2.2 VGG16网络结构图VGG设计的神经网络结构图： D：dropout图片变动过程：1：输出咱们的川建国（224x224x3）--->224x224x64--->112x112x642：112x112x64--->112x112x128--->56x56x1283：56x56x128--->56x56x256--->56x56x256--->28x28x2564：28x28x256--->28x28x512--->28x28x512--->14x14x5125：14x14x512--->14x14x512--->14x14x512--->7x7x512 变动过程第一个数字代表输出，最初一个数字代表这一层的输入，下一层的输出全连贯层：1、输出：7x7x512（25088），输入：40962、输出：4096，输入40963、输出：4096，输入1000 (因为进行的是1000个分类）在参考文献1中作者同时比拟了上面几种不同构造（VGG11、VGG16与VGG19）： 倡议： ...

download：PyTorch深度学习开发医学影像端到端判断我的项目运维部署：如何疾速无效地治理软件系统关键字：运维、部署、自动化、监控、平安古代软件系统由多个组件形成，这些组件须要一直地进行更新和保护。为了保证系统的稳定性和可靠性，咱们须要一个高效的运维部署流程。本文将介绍如何疾速无效地治理软件系统，进步运维效率和品质。 首先，自动化部署是进步运维效率和品质的要害。通过应用自动化工具和脚本，能够轻松地进行软件部署和配置，缩小手动操作带来的谬误和提早。同时，自动化部署还可能实现疾速回滚和版本控制，保证系统的稳定性和可靠性。 其次，监控是保障系统运行的重要伎俩。通过对系统各个组件的监控和告警，能够及时发现并解决问题，防止因故障而导致的业务中断。同时，监控数据也能够作为优化和改善零碎的根据，进步零碎的性能和效率。 另外，平安是运维部署的重要方面。在进行软件部署和保护时，须要留神爱护零碎的安全性，例如加密敏感信息、限度拜访权限等。同时，也须要定期进行破绽扫描和修复，确保零碎不受攻打和毁坏。 最初，团队合作和常识治理也是运维部署的重要方面。通过建设良好的团队合作机制和常识共享平台，能够增强团队成员之间的交换和单干，进步运维效率和品质。 综上所述，运维部署是软件系统治理中不可或缺的一环。通过自动化部署、监控、平安爱护和团队合作等伎俩，能够进步运维效率和品质，实现疾速无效地治理软件系统。

download：PyTorch深度学习开发医学影像端到端判断我的项目ChatGPT：开启人机交互新时代的AI语言模型 在现代科技疾速倒退的明天，人工智能曾经成为了一个备受关注的话题，而ChatGPT作为一种基于自然语言解决技术的AI语言模型，在人机交互方面扮演着越来越重要的角色。本文将介绍ChatGPT的基础知识、利用场景和将来瞻望等内容。 什么是ChatGPT？ChatGPT是由OpenAI研发的一种基于Transformer架构的大型AI语言模型，它能够实现自然语言生成和了解的工作，从而与人进行高度晦涩的对话。ChatGPT采纳了海量的训练数据和深度学习算法，从而能够一直地优化本身的预测和回复能力，让对话更加天然、灵便和人性化。 ChatGPT的利用场景ChatGPT在人机交互方面有着宽泛的利用场景，例如： 客服机器人：企业能够利用ChatGPT开发客服机器人，帮忙用户解答常见问题、提供服务反对等。智能助手：ChatGPT能够作为智能助手的核心技术，通过自然语言交互来实现日常事务、提供娱乐和学习等服务。语音辨认：ChatGPT能够与语音辨认技术联合，实现语音对话的性能，让人与机器之间的交互更加方便快捷。ChatGPT的将来瞻望随着人工智能技术的一直倒退，ChatGPT的利用前景也越来越广大。将来，咱们能够期待以下几个方面的倒退： 多语种反对：ChatGPT能够拓展到多种语言，让人们在寰球范畴内都可能应用它来进行自然语言交互。跨畛域利用：除了客服和娱乐畛域外，ChatGPT还能够拓展到医疗、金融、教育等各个领域，为人们提供更加全面的服务和反对。更加智能化：将来的ChatGPT将会领有更加智能的预测和回复能力，能够更好地了解人类的情感、语境和需要，让对话更加晦涩和天然。论断ChatGPT作为一种基于自然语言解决技术的AI语言模型，正在逐渐扭转人机交互的形式和状态。通过海量的训练数据和深度学习算法，ChatGPT能够实现高度晦涩、灵便和人性化的对话，为人们提供更加便当和高效的服务和反对。将来，咱们能够期待ChatGPT在多语种反对、跨畛域利用和智能化等方面的一直拓展和翻新。

download：PyTorch入门到进阶 实战计算机视觉与自然语言解决我的项目在诗歌中，晴天的云彩常被形容为“晴云片片明”，这是因为晴朗的天空中，云层状态和色彩都十分漂亮。以下是对晴云片片明景象的具体介绍。 什么是晴云片片明？晴云片片明是一种光学景象，指的是晴朗天空中的红色云层，因受到日光照耀而呈现出不同的状态和色彩变幻。通常状况下，云层呈现出红色或淡蓝色，但在特定的天气条件下，云层也可能呈现出金黄、粉红或橙色等不同的色彩。造成原理晴云片片明的造成原理与大气折射和散射无关。当太阳光线通过大气层时，因为大气分子的散射作用，太阳光线会呈现出不同的色彩，并且被散射的光线会在云层上反射和折射。这些反射和折射后的光线会在咱们的眼中造成不同的色彩和状态，从而呈现出晴云片片明的漂亮现象。参观形式参观晴云片片明最好的工夫是在晚上或黄昏时分，因为此时太阳光线照耀角度较低，产生的反射和折射作用更加强烈。此外，在参观时要抉择宽阔的视线，例如平地、海滨等中央，这样能够更好地观赏到云层的状态和色彩变动。总之，晴云片片明是一种十分漂亮的天然景象，它不仅给人们带来了视觉上的享受，同时也让咱们更加粗浅地领会到大自然的神奇和美好。

PyTorch深度学习技术指南PyTorch是一个基于Python的开源机器学习库，它提供了弱小的Tensor计算性能和灵便的高级神经网络构建工具。PyTorch已成为广受欢迎的机器学习框架之一，特地适宜于深度学习钻研和开发。在本篇文章中，咱们将具体介绍PyTorch深度学习的技术常识，包含张量、主动求导、神经网络、优化器等。 张量张量（Tensor）是PyTorch中最根底的数据结构，它相似于Numpy中的多维数组。能够应用PyTorch创立不同类型的张量，例如标量、向量、矩阵和高维张量。 创立张量应用torch.tensor()函数能够从Python列表或Numpy数组创立张量。例如，以下代码创立了一个3x3的浮点型零矩阵： import torchx = torch.tensor([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])也能够应用torch.zeros()、torch.ones()、torch.rand()等函数创立特定值的张量。 张量运算PyTorch反对各种张量运算，包含加法、乘法、点积等。例如，以下代码将两个张量相加： import torchx = torch.tensor([1.0, 2.0, 3.0])y = torch.tensor([4.0, 5.0, 6.0])z = x + yprint(z)张量形态能够应用tensor.size()函数获取张量的形态。例如，以下代码获取了一个3x3的零矩阵的形态： import torchx = torch.zeros(3, 3)shape = x.size()print(shape)GPU计算PyTorch还反对在GPU上进行张量计算，从而减速深度学习模型的训练和推理。能够应用.cuda()办法将张量移到GPU中。例如，以下代码将张量x移到GPU并进行乘法运算： import torchx = torch.ones(3, 3).cuda()y = torch.ones(3, 3).cuda()z = x * yprint(z)主动求导主动求导是深度学习中十分重要的性能，它能够主动计算简单的梯度并更新模型参数。PyTorch提供了灵便的主动求导机制，使得深度学习模型的开发变得更加简略。 创立变量为了可能应用主动求导性能，须要将张量转换为torch.autograd.Variable类型。例如，以下代码创立了一个变量并将其与另一个变量相加： import torchx = torch.autograd.Variable(torch.tensor([1.0]), requires_grad=True)y = torch.autograd.Variable(torch.tensor([2.0]), requires_grad=True)z = x + yprint(z)在这个例子中，requires_grad=True示意咱们须要计算变量的梯度。 计算梯度能够应用.backward()办法计算变量的梯度。例如，以下代码计算了变量z对变量x和y的梯度： import torchx = torch.autograd.Variable(torch.tensor([1.0]), requires_grad=True)y = torch.autograd.Variable(torch.tensor([2.0]), requires_grad=True)z = x + yz.backward()print(x.grad)print(y.grad)禁用梯度计算有时候须要禁用某些变量的梯度计算，能够应用.detach()办法将变量从计算图中分离出来，例如以下代码： ...

PyTorch深度学习开发医学影像端到端判断我的项目 download：https://www.sisuoit.com/itkechengPyTorch是一种基于Python的开源机器学习库，它能够帮忙开发人员疾速构建和训练深度神经网络模型。PyTorch具备很多长处，如动静计算图、易于调试和扩大等，上面将对其进行具体介绍。 一、装置PyTorch要应用PyTorch，首先须要在本地环境中装置Python和相干的依赖库，而后能够通过以下命令装置PyTorch： pip install torch 二、创立深度神经网络模型应用PyTorch能够不便地创立深度神经网络模型，并且反对多种类型的层和激活函数，例如全连贯层、卷积层、池化层、ReLU激活函数等。以下是一个简略的深度神经网络模型示例： import torchimport torch.nn as nnimport torch.nn.functional as Fclass Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(3, 6, 5) self.pool = nn.MaxPool2d(2, 2) self.conv2 = nn.Conv2d(6, 16, 5) self.fc1 = nn.Linear(16 * 5 * 5, 120) self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) def forward(self, x): x = self.pool(F.relu(self.conv1(x))) x = self.pool(F.relu(self.conv2(x))) x = x.view(-1, 16 * 5 * 5) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return xnet = Net()以上代码定义了一个蕴含两个卷积层和三个全连贯层的深度神经网络模型，用于解决CIFAR-10数据集分类问题。 ...

是的，torchvision 的 transforms.Resize 能够批改图像的大小和比例。如果您只指定了一个维度（例如高度），则另一个维度（例如宽度）将按比例调整以放弃原始图像的纵横比。如果您指定两个维度，则图像将被拉伸以填充新尺寸。 以下是一个示例，展现了 transforms.Resize 如何批改图像的大小和比例： import torchfrom torchvision import transformsfrom PIL import Imageimg = Image.open("example.jpg") # 原始图像print(img.size) # 输入原始图像尺寸# 将图像高度调整为 256 像素，宽度将按比例调整以放弃纵横比resize_transform = transforms.Resize((256,))resized_img = resize_transform(img)print(resized_img.size) # 输入批改后的图像尺寸# 将图像调整为 224x224 像素，不放弃纵横比resize_transform = transforms.Resize((224, 224))resized_img = resize_transform(img)print(resized_img.size) # 输入批改后的图像尺寸输入后果： (640, 360)(455, 256)(224, 224)在第一个示例中，图像高度被调整为 256 像素，宽度按比例调整以放弃原始图像的纵横比。在第二个示例中，图像被调整为 224x224 像素，不放弃纵横比，因而图像可能会被拉伸。

我的模型须要线上部署了，想间接应用 onnx，而不是 pytorch，所以我须要把代码中对于 pytorch 的都删除了，比方上面这段代码，怎么应用其余库代替？ from torchvision import transformspreprocess = transforms.Compose([ transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] )])上面是 ChatGPT 给我的答案： 能够应用 Pillow 和 numpy 库代替 torchvision 和 torch 中的操作，示例代码如下： from PIL import Imageimport numpy as npdef preprocess(image_path): image = Image.open(image_path) image = image.resize((224, 224)) image = np.array(image) image = image.transpose((2, 0, 1)) image = image.astype(np.float32) image /= 255.0 mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1)) std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1)) image = (image - mean) / std return image这个函数将承受图像文件门路作为输出并返回预处理后的图像。 ...

image dataset：https://pytorch.org/vision/stable/datasets.html text dataset：https://pytorch.org/text/stable/datasets.html audio dataset：https://pytorch.org/audio/stable/datasets.html 参考资料：https://pytorch.org/tutorials/beginner/basics/data_tutorial.html的Loading a Dataset上方文档给出的链接。

问题形容：首先已知两个数据集，x_data和y_data须要求得两个数据集之间的线性关系。（目标是失去w和b） 搞清楚整个思路，代码编写就很轻松。1.数据集已知。2.建设线性关系，首先建设线性模型。（class LinearModel中必须包含init和forward，init是对模型的建设包含w和b的参数，forward就是前馈函数返回y_hat）3.construct和optimizer(构建损失函数和优化器)4.多个epoch循环，每次求得通过模型失去y_hat,而后和y_data一减失去loss，求导之前记得把梯度置零不然梯度会累加，而后反向流传计算失去梯度d(loss)/d(w),最初用optimizer进行更新参数即可。 以上就是整个思路流程，上面是具体代码和正文：import torch#part one 导入数据集x_data=torch.Tensor([[1.0],[2.0],[3.0]])y_data=torch.Tensor([[2.0],[4.0],[6.0]])print(x_data)#part two 建设模型#所有的模型都要继承torch.nn.moduleclass LinearModel(torch.nn.Module):#外面必须蕴含init，forward。#backward它会主动帮咱们算 def __init__(self): super(LinearModel, self).__init__() self.linear=torch.nn.Linear(1,1)#这里是在结构对象，参数是权重和偏置 def forward(self,x): y_pred=self.linear(x)#这里是因为python中的call函数，使得对象能够实例化 #称之为callable #linear是一个激活函数，激活函数就是在神经网络每层将输出映射到输入的函数， #除了linear这个激活函数，还有sigmoid等其余激活函数 return y_predmodel=LinearModel()#part 3 construct and optimizercriterion=torch.nn.MSELoss(size_average=False)optimizer=torch.optim.SGD(model.parameters(),lr=0.01)#part fourfor epoch in range(1000): y_pred=model(x_daa) loss=criterion(y_pred,y_data) print(epoch,loss) optimizer.zero_grad()#梯度置零，把loss对于weight的导数置零,（如同还缩小内存耗费，搜一下？） loss.backward()#反向流传即计算梯度，求得x.grad=d(loss)/d(x) optimizer.step()#进行更新，x=x-lr*x.gradprint('w=',model.linear.weight.item())print('b=',model.linear.bias.item())#test modelx_test=torch.Tensor([4.0])y_test=model(x_test)print("y_pred=",y_test.data)

scikit-learn是Python中最好的机器学习库，而PyTorch又为咱们构建模型提供了不便的操作，是否将它们的长处整合起来呢？在本文中，咱们将介绍如何应用 scikit-learn中的网格搜寻性能来调整 PyTorch 深度学习模型的超参数: 如何包装 PyTorch 模型以用于 scikit-learn 以及如何应用网格搜寻如何网格搜寻常见的神经网络参数，如学习率、Dropout、epochs、神经元数在本人的我的项目上定义本人的超参数调优试验如何在 scikit-learn 中应用 PyTorch 模型要让PyTorch 模型能够在 scikit-learn 中应用的一个最简略的办法是应用skorch包。这个包为 PyTorch 模型提供与 scikit-learn 兼容的 API。 在skorch中，有分类神经网络的NeuralNetClassifier和回归神经网络的NeuralNetRegressor。 pip install skorch 要应用这些包装器，必须应用 nn.Module 将 PyTorch 模型定义为类，而后在结构 NeuralNetClassifier 类时将类的名称传递给模块参数。 例如： class MyClassifier(nn.Module): def __init__(self): super().__init__() ... def forward(self, x): ... return x # create the skorch wrapper model = NeuralNetClassifier( module=MyClassifier )NeuralNetClassifier 类的构造函数能够取得传递给 model.fit() 调用的参数（在 scikit-learn 模型中调用训练循环的办法），例如轮次数和批量大小等。 例如： model = NeuralNetClassifier( module=MyClassifier, max_epochs=150, batch_size=10 )NeuralNetClassifier类的构造函数也能够承受新的参数，这些参数能够传递给你的模型类的构造函数，要求是必须在它后面加上module__(两个下划线)。这些新参数可能在构造函数中带有默认值，但当包装器实例化模型时，它们将被笼罩。例如: ...

混合精度曾经成为训练大型深度学习模型的必要条件，但也带来了许多挑战。将模型参数和梯度转换为较低精度数据类型（如FP16）能够放慢训练速度，但也会带来数值稳定性的问题。应用进行FP16 训练梯度更容易溢出或有余，导致优化器计算不准确，以及产生累加器超出数据类型范畴的等问题。 在这篇文章中，咱们将探讨混合准确训练的数值稳定性问题。为了解决数值上的不稳定性，大型训练工作常常会被搁置数天，会导致我的项目的延期。所以咱们能够引入Tensor Collection Hook来监控训练期间的梯度条件，这样能够更好地了解模型的外部状态，更快地辨认数值不稳定性。 在晚期训练阶段理解模型的外部状态能够判断模型在前期训练中是否容易呈现不稳固是十分好的方法，如果可能在训练的头几个小时就能辨认出梯度不稳定性，能够帮忙咱们晋升很大的效率。所以本文提供了一系列值得关注的正告，以及数值不稳定性的补救措施。 混合精度训练随着深度学习持续向更大的根底模型倒退。像GPT和T5这样的大型语言模型当初主导着NLP，在CV中比照模型(如CLIP)的泛化成果优于传统的监督模型。特地是CLIP的学习文本嵌入意味着它能够执行超过过来CV模型能力的零样本和少样本推理，训练这些模型都是一个挑战。 这些大型的模型通常波及深度transformers网络，包含视觉和文本，并且蕴含数十亿个参数。GPT3有1750亿个参数，CLIP则是在数百tb的图像上进行训练的。模型和数据的大小意味着模型须要在大型GPU集群上进行数周甚至数月的训练。为了减速训练缩小所需gpu的数量，模型通常以混合精度进行训练。 混合准确训练将一些训练操作放在FP16中，而不是FP32。在FP16中进行的操作须要更少的内存，并且在古代gpu上能够比FP32的处理速度快8倍。只管在FP16中训练的大多数模型精度较低，但因为适度的参数化它们没有显示出任何的性能降落。 随着英伟达在Volta架构中引入Tensor Cores，低精度浮点减速训练更加疾速。因为深度学习模型有很多参数，任何一个参数的确切值通常都不重要。通过用16位而不是32位来示意数字，能够一次性在Tensor Core寄存器中拟合更多参数，减少每个操作的并行性。 但FP16的训练是存在挑战性的。因为FP16不能示意绝对值大于65,504或小于5.96e-8的数字。深度学习框架例如如PyTorch带有内置工具来解决FP16的限度(梯度缩放和主动混合精度)。但即便进行了这些安全检查，因为参数或梯度超出可用范畴而导致大型训练工作失败的状况也很常见。深度学习的一些组件在FP32中施展得很好，然而例如BN通常须要十分细粒度的调整，在FP16的限度下会导致数值不稳固，或者不能产生足够的精度使模型正确收敛。这意味着模型并不能自觉地转换为FP16。 所以深度学习框架应用主动混合精度(AMP)，它通过一个事后定义的FP16训练平安操作列表。AMP只转换模型中被认为平安的局部，同时将须要更高精度的操作保留在FP32中。另外在混合精度训练中模型中通过给一些接近于零梯度（低于FP16的最小范畴）的损失乘以肯定数值来取得更大的梯度，而后在利用优化器更新模型权重时将按比例向下调整来解决梯度过小的问题，这种办法被称为梯度缩放。 上面是PyTorch中一个典型的AMP训练循环示例。 梯度缩放器scaler会将损失乘以一个可变的量。如果在梯度中察看到nan，则将倍数升高一半，直到nan隐没，而后在没有呈现nan的状况下，默认每2000步逐步减少倍数。这样会放弃梯度在FP16范畴内，同时也避免梯度变为零。 训练不稳固的案例只管框架都尽了最大的致力，但PyTorch和TensorFlow中内置的工具都不能阻止在FP16中呈现的数值不稳固状况。 在HuggingFace的T5实现中，即便在训练之后模型变体也会产生INF值。在十分深的T5模型中，注意力值会在层上累积，最终达到FP16范畴之外，这会导致值无穷大，比方在BN层中呈现nan。他们是通过将INF值改为在FP16的最大值解决了这个问题，并且发现这对推断的影响能够忽略不计。 另一个常见问题是ADAM优化器的限度。作为一个小更新，ADAM应用梯度的第一和第二矩的挪动均匀来适应模型中每个参数的学习率。 这里Beta1 和 Beta2 是每个时刻的挪动均匀参数，通常别离设置为 .9 和 .999。用 beta 参数除以步数的幂打消了更新中的初始偏差。在更新步骤中，向二阶矩参数增加一个小的 epsilon 以防止被零除产生谬误。epsilon 的典型默认值是 1e-8。但 FP16 的最小值为 5.96e-8。这意味着如果二阶矩太小，更新将除以零。所以在 PyTorch 中为了训练不会发散，更新将跳过该步骤的更改。但问题依然存在尤其是在 Beta2=.999 的状况下，任何小于 5.96e-8 的梯度都可能会在较长时间内进行参数的权重更新，优化器会进入不稳固状态。 ADAM的长处是通过应用这两个矩，能够调整每个参数的学习率。对于较慢的学习参数，能够放慢学习速度，而对于疾速学习参数，能够减慢学习速度。但如果对多个步骤的梯度计算为零，即便是很小的正值也会导致模型在学习率有工夫向下调整之前发散。 另外PyTorch目前还一个问题，在应用混合精度时主动将epsilon更改为1e-7，这能够帮忙避免梯度移回正值时发散。然而这样做会带来一个新的问题，当咱们晓得梯度在雷同的范畴内时，减少会升高了优化器适应学习率的能力。所以自觉的减少epsilon也不能解决因为零梯度而导致训练停滞的状况。 CLIP训练中的梯度缩放为了进一步证实训练中可能呈现的不稳定性，咱们在CLIP图像模型上构建了一系列试验。CLIP是一种基于比照学习的模型，它通过视觉转换器和形容这些图像的文本嵌入同时学习图像。比照组件试图在每批数据中将图像匹配回原始形容。因为损失是在批次中计算的，在较大批次上的训练已被证实能提供更好的后果。 CLIP同时训练两个transformers模型，一个相似GPT的语言模型和一个ViT图像模型。两种模型的深度都为梯度增长发明了超过FP16限度的机会。OpenClip（arxiv 2212.07143）实现形容了应用FP16时的训练不稳定性。 Tensor Collection Hook 为了更好地了解训练期间的外部模型状态，咱们开发了一个Tensor Collection Hook (TCH)。TCH能够包装一个模型，并定期收集对于权重、梯度、损失、输出、输入和优化器状态的摘要信息。 例如，在这个试验中，咱们要找到和记录训练过程中的梯度条件。比方可能想每隔10步从每一层收集梯度范数、最小值、最大值、绝对值、平均值和标准差，并在 TensorBoard 中可视化后果。 而后能够用out_dir作为--logdir输出启动TensorBoard。 试验 为了重现CLIP中的训练不稳定性，用于OpenCLIP训练Laion 50亿图像数据集的一个子集。咱们用TCH包装模型，定期保留模型梯度、权重和优化器时刻的状态，这样就能够察看到不稳固产生时模型外部产生了什么。 从vvi - h -14变体开始，OpenCLIP作者形容了在训练期间存在稳定性问题。从预训练的检查点开始，将学习率进步到1-e4，与CLIP训练后半段的学习率类似。在训练进行到300步时，无意间断引入10个难度较大的训练批次。 ...

对于数据迷信我的项目来说，咱们始终都很关注模型的训练和体现，然而在理论工作中如何启动和运行咱们的模型是模型上线的最初一步也是最重要的工作。 明天我将通过一个简略的案例：部署一个PyTorch图像分类模型，介绍这个最重要的步骤。 咱们这里应用PyTorch和Flask。能够应用pip install torch和pip install flask装置这些包。 web利用为Flask创立一个文件app.py和一个路由： fromflaskimportFlask importtorch app=Flask(__name__) @app.route('/') defhome(): return'Welcome to the PyTorch Flask app!'当初咱们能够运行python app.py，如果没有问题，你能够拜访http://localhost:5000/，应该会看到一条简略的音讯——“Welcome to the PyTorch Flask app!” 这就阐明咱们flask的web服务曾经能够工作了，当初让咱们增加一些代码，将数据传递给咱们的模型! 增加更多的导入 fromflaskimportFlask, request, render_template fromPILimportImage importtorch importtorchvision.transformsastransforms而后再将主页的内容换成一个HTML页面 @app.route('/') defhome(): returnrender_template('home.html')创立一个templates文件夹，而后创立home.html。 <html> <head> <title>PyTorch Image Classification</title> </head> <body> <h1>PyTorch Image Classification</h1> <formmethod="POST"enctype="multipart/form-data"action="/predict"> <inputtype="file"name="image"> <inputtype="submit"value="Predict"> </form> </body> </html>HTML非常简单——有一个上传按钮，能够上传咱们想要运行模型的任何数据(在咱们的例子中是图像)。 以上都是根本的web利用的内容，上面就是要将这个web利用和咱们的pytorch模型的推理联合。 加载模型在home route下面，加载咱们的模型。 model=torch.jit.load('path/to/model.pth')咱们都晓得，模型的输出是张量，所以对于图片来说，咱们须要将其转换为张量、还要进行例如调整大小或其余模式的预处理（这与训练时的解决一样）。 咱们解决的是图像，所以预处理很简略 defprocess_image(image): # Preprocess image for model transformation=transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) image_tensor=transformation(image).unsqueeze(0) returnimage_tensor咱们还须要一个数组来示意类，本文只有2类 ...

内容导读 TorchServe 自 2020 年 4 月推出至今，经验了 2 年多的倒退，变得愈发成熟和稳固，本文将对 TorchServe 进行全面介绍。 TorchServe 是 PyTorch 中将模型部署到生产环境的首选解决方案。它是一个性能良好且可扩大的工具，用 HTTP 或 HTTPS API 封装模型。TorchServe 的前端是用 Java 实现的，能够解决多种工作，包含为部署模型调配 workers、负责客户端和服务器之间通信等。其 Python 后端次要负责解决 inference service。 ![https://tva1.sinaimg.cn/large...]()图一：TorchServe performance Tuning 流程总览此外，它还反对 AB 测试、dynamic batching、logging 和 metrics 的多种 model serving 及 versioning，4 个公开 API 包含： Inference API：监听 8080 端口，默认状况下可通过 localhost 拜访，能够在 TorchServe configuration 中进行配置，并反对从模型中获取 predictions。Explanation API：在 hood 下应用 Captum 提供正在部署的模型的阐明，并 监听 8080 端口。Management API：容许注册或勾销注册并形容模型。它还容许用户减少或缩小部署模型的 workers 的数量。Metrics API：在默认状况下监听 8082 端口，使用户能够监测正在部署的模型。TorchServe 通过反对 batch inference 及部署模型的多个 workers，使得用户得以扩大模型部署并解决峰值流量。这种扩大可通过 Management API 及 configuration file 中的设置来实现。此外，Metrics API 能够通过默认及自定义 metrics 来监测模型部署。其余高级设置，如接管申请的队列长度、a batch of inputs 的最大期待时长以及其余属性，都能够通过 config file（启动时能够传递到 TorchServe）进行配置。用 TorchServe 部署模型的步骤包含：1、装置 TorchServe、model archiver 及其它依赖2、抉择一个适合的默认 handler（如图像分类等）或创立一个自定义 handler3、应用 Torcharchive 将 model artifacts 和 handler 打包成一个 .mar 文件，并将其放入 model store4、开始部署模型5、运行推理 ...

PyTorch 中的 graph mode 在性能方面示意更为杰出，本文介绍 Torch.FX 这个弱小工具，能够捕获和优化 PyTorch 程序 graph。一、简介PyTorch 反对两种执行模式：eager mode 和 graph mode。 eager mode 中，模型中的运算符在读取时会立刻执行，它易于应用，对机器学习从业者更敌对，因而被设置为默认的执行模式。 graph mode 中，运算符先被合成一个 graph，而后作为一个整体进行编译和执行，它的性能更高，因而在理论生产中大量应用。 具体来说，graph mode 反对算子交融，两个算子通过合并，能够升高或本地化内存读取以及内核启动总开销。 交融能够是横向 (horizontal) 的：采取利用于多个 operand 的繁多操作（如 BatchNorm），并将这些 operand 合并到一个数组中。 交融也能够是纵向 (vertical) 的：将一个内核与另一个内核合并，后者须要应用第一个内核的输入（如 ReLU 后接卷积）。 Torch.FX（缩写为 FX）是一个公开可用的工具包，作为 PyTorch 软件包的一部分，反对 graph mode 的执行。它能够： 从 PyTorch 程序中获取 graph容许开发者在获取的 graph 上编写 transformation**Meta 外部先前曾经在用 FX 来优化生产模型 (production model) 的训练吞吐量 (training throughput)。本文将通过介绍 Meta 开发的基于 FX 的优化，来展现利用图构造转换 (graph transformation) 优化 PyTorch 部署模型性能的办法 ...

因为上篇文章中装置的PyTorch版本是1.13，再装置PyTorchGeometric的时候发现最高反对的是1.12，所有只能在创立一个虚拟环境，再装置1.12的pytorch，再装置Geometric。查看官网装置文档：https://pytorch-geometric.rea... 1 创立虚拟环境PyGconda create -n PyG python=3.9如遇到问题，见上一篇。 2 装置Pytorch1.12版本因为Pytorch1.12不是最新版，所以须要找到以前的版本进行装置，关上官网：抉择1.12版本，再看conda上面的内容，我笔记本没有独立显卡，就抉择最上面的cpu版本：拷贝装置命令： conda install pytorch==1.12.1 torchvision==0.13.1 torchaudio==0.12.1 cpuonly -c pytorch 3装置pytorch-geometric3.1 疾速安装法关上页面https://pytorch-geometric.rea...外面有一种疾速安装法，就是像之前装置pytorch一样，抉择相干配置后，网页会主动生成一个命令，间接复制这个命令去装置，如下图所示。但网上有人说容易出问题，为了保险起见，咱们抉择官网下面的另外一种办法去一步步装置。 3.2Installation via Pip Wheels首先查看本人之前装置的pytorch版本，以及CUDA版本，我这里用的cpu，所以CUDA版本会提醒None。 (PyG) C:\Users\Administrator\anaconda3\envs\PyG>python -c "import torch; print(torch.__version__)">>>1.12.1(PyG) C:\Users\Administrator\anaconda3\envs\PyG>python -c "import torch; print(torch.version.cuda)">>>None第二步：依照官网的例子进行装置须要三个pip命令： pip install torch-scatter -f https://data.pyg.org/whl/torch-${TORCH}+${CUDA}.htmlpip install torch-sparse -f https://data.pyg.org/whl/torch-${TORCH}+${CUDA}.htmlpip install torch-geometric我以后的PyTorch版本是1.12.1，所以对应的${TORCH}值是1.12.0；我的CUDA版本是没有的，用cpu，所以${CUDA}的值对应是cpu，所以我以后环境装置的命令应该是： pip install torch-scatter -f https://data.pyg.org/whl/torch-1.12.0+cpu.htmlpip install torch-sparse -f https://data.pyg.org/whl/torch-1.12.0+cpu.htmlpip install torch-geometric第三步，运行命令第一个命令运行完之后，胜利。第二个命令运行完之后，在装置过程中报错了，谬误提醒如下： raise ReadTimeoutError(self._pool, None, "Read timed out.")pip._vendor.urllib3.exceptions.ReadTimeoutError: HTTPSConnectionPool(host='files.pythonhosted.org', port=443): Read timed out.在pip装置过程中超时了，因为下载的文件40M，从国外下载过去速度比较慢，只有20k/s左右的速度，这时候须要设置pip的超时工夫，把工夫设置更长一些： pip --default-timeout=10000 install torch-sparse -f https://data.pyg.org/whl/torch-1.12.0+cpu.html装置胜利，下载40M（scipy-1.9.3-cp39-cp39-win_amd64.whl (40.2 MB)）的货色花了半个多小时，这速度的确耗不起啊第三个命令，装置torch-geometric，汲取后面教训，缩短pip的期待时长：pip --default-timeout=10000 install torch-geometric装置胜利 ...

上一篇写了如何装置anaconda，这一批接着装置PyTorch。 1 在anaconda中创立虚拟环境为了可能让一台电脑上跑多个环节，最好是把包都装置在虚拟环境中，这样就不会影响零碎的anaconda环境。创立anaconda的虚拟环境有两种形式，第一种是在anaconda的navigator中装置，如下图：第二形式是用命令行创立虚拟环境： conda create -n pytorch_cpu python=3.9后果报错了： Collecting package metadata (current_repodata.json): failedCondaSSLError: OpenSSL appears to be unavailable on this machine. OpenSSL is required todownload and install packages.Exception: HTTPSConnectionPool(host='mirrors.tuna.tsinghua.edu.cn', port=443): Max retries exceeded with url: /anaconda/cloud/win-64/current_repodata.json (Caused by SSLError("Can't connect to HTTPS URL because the SSL module is not available."))这篇文章中给出了很多具体方法https://www.mixker.com/tech/287/我先用的第一种办法：将门路 miniconda3/Library/bin 上面的两个文件：libcrypto-1_1-x64.dll ；libssl-1_1-x64.dll，复制到门路 miniconda3/DLLs 下。再次创立虚拟环境时，有报错了，于是采纳第四种办法：将C:\Users\Administrator目录下的.condarc文件关上，复制上面内容替换原来文件中的内容： channels: - defaultsshow_channel_urls: truechannel_alias: https://mirrors.tuna.tsinghua.edu.cn/anacondadefault_channels: - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/pro - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2custom_channels: conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud留神：外面提到的第三个办法集体不倡议应用，因为.condarc文件中保留了镜像信息，删除意味着用原来默认的资源了。装置胜利后，在你的anaconda目录的envs目录下，就有刚刚创立的pytorch_cpu文件夹了。在命令行输出activate pytorch_cpu，进入刚创立的pytorch_cpu虚拟环境中，后面有一个括号提醒（pytorch_cpu）才示意进入了虚拟环境： ...

内容导读：近日，PyTorch 团队在官网博客发表 Pytorch 1.13 公布。本文将具体围绕新版本的 4 大亮点开展介绍。据官网介绍，PyTorch 1.13 中包含了 BetterTransformer 的稳定版，且不再反对 CUDA 10.2 及 11.3，并实现了向 CUDA 11.6 及 11.7 的迁徙。此外 Beta 版还减少了对 Apple M1 芯片及 functorch 的反对。 PyTorch 1.13 不可错过的亮点汇总： 1.BetterTransformer 功能集 (feature set) 反对个别的 Transformer 模型在推理过程中，无需批改模型即可进行 fastpath 执行。此外改良还包含对 Transformer 模型中罕用 size 进行减速的 add+matmul 线性代数内核，现已默认启用嵌套 Tensor。 2.不再反对旧的 CUDA 版本，引入 Nvidia 推出的最新 CUDA 版本。这使得 PyTorch 和新的 NVIDIA Open GPU 内核模块得以反对 C++17。 3.functorch 从独自软件包变为可间接通过 import functorch 导入 PyTorch 应用，无需再独自装置。 4.测试为 M1 芯片 Mac 提供本地构建，并提供更好的 PyTorch API 反对。 ...

2022年9月，麒麟软件正式推出“星光麒麟万物智联操作系统”，开启面向全场景的新一代操作系统翻新之路。近日，“星光麒麟万物智联操作系统”首个版本——星光麒麟操作系统1.0（StarKylin 1.0）与慧为科技平板电脑实现了适配优化。在星光麒麟操作系统开发过程中，openKylin社区作为“星光麒麟”万物智联操作系统的翻新根底，凋谢合作，聚力倒退，充分发挥社区Kernel SIG、UKUI SIG，以及HTML5 SIG等翻新技术劣势，为万物智联奉献科技力量，打造面向全场景的新一代操作系统。星光麒麟操作系统1.0反对软硬件一体的双体系架构平安框架，实现H5和安卓利用生态兼容和用户体验交融对立，反对分布式应用协同性能，反对国内自主芯片厂商支流挪动芯片。搭载星光麒麟操作系统的TVE1206R平板深圳慧为智能科技TVE1206R平板搭载国产高端芯片，采纳超薄全金属一体机身，厚度仅7.4mm，领有超10小时续航能力，内置国密芯片，打造内生平安体系，并装备分体式可拆卸键盘和可充电主动式电容笔。星光麒麟操作系统1.0将首先笼罩平板、大屏、手持设施和可穿戴设施业务需要，基于Linux内核自主研发，领有核心技术知识产权。零碎采纳HTML5技术构建交融H5、Linux以及AOSP的对立运行框架，兼容AOSP利用生态，领有丰盛的软硬件生态撑持。在研发过程中，星光麒麟操作系统1.0充沛吸取openKylin社区营养，借助河汉麒麟桌面操作系统的技术教训，满足各行业面向万物智联时代的利用需要。星光麒麟万物智联操作系统具备“弹性扩大、智能互联、内生平安、对立框架”的产品个性，融入国产AI框架，反对多种新型人机交互形式。将来，星光麒麟万物智联操作系统还将笼罩工控、物联网以及边缘计算等类型设施，满足海量业务零碎互联场景，以“终端互联——场景互联——智能倒退”的策略布局，满足国家、行业、企业、集体数字化利用需要。openKylin社区也将持续助力星光麒麟我的项目研发团队，秉承好高鹜远的工匠精力，不忘初心，专一平安，潜心打造国产万物智联操作系统标志性平安产品。同时咱们也期待能与更多的产业搭档合作翻新，一起独特拓展万物智联边界，为促成数字技术和实体经济的深度交融、推动数字经济高质量倒退作出更大的奉献！ openKylin（凋谢麒麟）社区旨在以“共创”为外围，在开源、被迫、平等、合作的根底上，通过开源、凋谢的形式与企业构建合作伙伴生态体系，独特打造桌面操作系统顶级社区，推动Linux开源技术及其软硬件生态凋敝倒退。社区首批理事成员单位包含麒麟软件、普华根底软件、中科方德、麒麟信安、凝思软件、一铭软件、中兴新支点、元心科技、中国电科32所、技德零碎、北京麟卓、先进操作系统翻新核心等13家产业同仁和行业机构。 审核：openKylin

download：PyTorch入门到进阶 实战计算机视觉与自然语言解决我的项目内附材料文档ArrayDeque深度解析概述ArrayDeque这个容器不晓得大家在平时的工作中使用的多吗？它是一个十分弱小的容器，既能够作为队列实现FIFO先进先出的功能，也具备栈的功能实现FILO先进后出的功能，那么它到底是怎么样的呢？性能又如何？ArrayDeque介绍ArrayDeque次要是基于数组实现的Deque(Double Ended Queue)双端队列，即双端队列，它既能够当作栈使用，也能够当作队列使用。 ArrayDeque是一个没有容量限度的双端队列，底层是基于数组实现，会主动扩容。ArrayDeque不是线程平安的。ArrayDeque不能够存取null元素。当作为栈使用时，性能比Stack好；当作为队列使用时，性能比LinkedList好。 实现了Queue接口，它实践上是一个单端队列，只能操作队列的一端。实现了Deque接口，Deque集成了Queue接口，有api能够同时操作队列的双端。实现了Cloneable接口，阐明该队列反对clone。实现了Serializable接口，标记该接口反对序列化操作。 构造方法 办法阐明ArrayDeque()结构一个初始容量为16的数组双端队列ArrayDeque(int numElements)结构一个初始容量为numElements的数组双端队列ArrayDeque(Collection<? extends E> c)结构一个初始内容未c的数组双端队列要害办法增加相干办法 等价办法阐明add(e)addLast(e)向队列尾部增加元素offer(e)offerLast(e)向队列尾部增加元素addFirst(e)offerFirst(e)向队列头部增加元素 add前缀的办法，假如超过容量限度，增加失败，会抛出运行时异样offer前缀的办法，比拟非凡，假如超过容量限度，会返回指定值true false 队列获取元素相干办法 等价办法阐明remove()removeFirst()获取并且删除队列头部元素poll()pollFirst()获取并且删除队列头部元素removeLast()pollLast()获取并且删除队列尾部 remove前缀的办法，假如容量为空，会抛出运行时异样offer前缀的办法，假如容量为空，会返回指定值null 办法等价办法阐明element()getFirst()查看队列头部元素peek()peekFirst()查看队列头部元素getLast()peekLast()查看队列尾部元素 peek前缀的办法，假如容量为空，会返回指定true，false，其余办法失败会抛出异样。 栈相干办法等价办法阐明push(e)addFirst(e)向栈中增加元素pop()removeFirst()获取栈顶元素peek()peekFirst()查看栈顶元素其余办法阐明removeFirstOccurrence(Object o)删除队列中第一次相等的元素removeLastOccurrence(Object o)删除队列中最初一个相等的元素tips：粗疏操作是返回指定值还是抛出异样，倡议看源码的javadoc，写的十分分明了。使用案例 测试队列功能 @Test public void test1() { Deque<String> deque = new ArrayDeque<>(); deque.add("1"); deque.offer("2"); deque.offerLast("3"); System.out.println(deque); String poll = deque.poll(); System.out.println(poll); System.out.println(deque);}测试栈的功能 @Test public void test2() { Deque<String> deque = new ArrayDeque<>(); deque.push("1"); deque.push("2"); deque.push("3"); String pop = deque.pop(); System.out.println(pop);}测试存储null数据 @Test public void test3() { Deque<String> deque = new ArrayDeque<>(); boolean offerResult = deque.offer(null); System.out.println(offerResult); System.out.println(deque);}测试poll和remove的区别 ...

原文链接 torch.nnpytorch中文文档链接：torch.nn 在__init__()函数里定义，定义的是一个类： torch.nn.functionalpytorch中文文档链接：torch.nn.functional 在__forward()__函数里定义，定义的是一个函数： 两者的区别torch.nn中是一个定义的类，以class xx来定义的，能够提取变动的学习参数。 torch.nn.functional是一个函数，由def function( )定义，是一个固定的运算公式。 深度学习中会有很多权重是在不断更新的，所以须要采纳类的形式，以确保能在参数发生变化时仍能应用咱们之前定好的运算步骤。因而如果模型有可学习的参数，应该应用nn.Module，否则两个没有区别。然而简略的计算不须要新建一个类来做，所以应用nn.functional定义函数就能够。 即：层内有variable的状况用nn定义，否则用nn.functional定义。 学习更多编程常识，请关注我的公众号： 代码的路

原文链接 1. 通道数问题形容一个像素点，如果是灰度，那么只须要一个数值来形容它，就是单通道。如果有RGB三种色彩来形容它，就是三通道。最后输出的图片样本的 channels ，取决于图片类型；卷积操作实现后输入的 out_channels ，取决于卷积核的数量。此时的 out_channels 也会作为下一次卷积时的卷积核的 in_channels；卷积核中的 in_channels ，下面曾经说了，就是上一次卷积的 out_channels ，如果是第一次做卷积，就是样本图片的 channels 。举个例子，假如现有一个为 6×6×3的图片样本，应用 3×3×3 的卷积核（filter）进行卷积操作。此时输出图片的 channels 为 3，而卷积核中的 in_channels 与须要进行卷积操作的数据的 channels 统一（就是图片样本，为3）。接下来进行卷积操作，卷积核中的27个数字与别离与样本对应相乘后，再进行求和，失去第一个后果。顺次进行，最终失去 4×4的后果。因为只有一个卷积核，所以最终失去的后果为 4×4×1，out_channels 为 1。如下图所示： 在理论利用中，都会应用多个卷积核。这里如果再加一个卷积核，就会失去 4×4×2的后果。如下图所示： 2. nn.Conv2dclass torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True)nn.Conv2d的性能是：对由多个输出立体组成的输出信号进行二维卷积。输出信号的模式为： $$(N,C_{in},H,W)$$ （1）参数阐明N：示意batch size（批处理参数） C_{in}：示意channel个数 H，W：别离示意特色图的高和宽。 stride(步长)：步长，默认为1，能够设为1个int型数或者一个(int, int)型的tuple。 kernel_size：卷积核的宽度和长度，单个整数或由两个整数形成的list/tuple。如为单个整数，则示意在各个空间维度的雷同长度。 padding(补0)：管制zero-padding的数目，padding是在卷积之前补0。 dilation(扩张)：管制kernel点（卷积核点）的间距; 能够在此github地址查看:Dilated convolution animations groups(卷积核个数)：通常来说，卷积个数惟一，然而对某些状况，能够设置范畴在1 —— in_channels中数目的卷积核： （2）图像尺寸通过一次卷积之后，生成的图的大小： (original_size - (kernal_size - 1)) / stride 3. nn.ConvTranspose2dnn.ConvTranspose2d的性能是进行反卷积操作 ...

间接本人写model是要正则的模型，reg_type抉择'l1'还是l2，coef是系数。 def regularization(model:nn.Module, reg_type,coef): int_type=int(reg_type[1]) reg_loss = 0 for module in model.modules(): for param in module.parameters(): reg_loss+=torch.norm(param,int_type) return reg_loss*coef代码是一个小例子，对哪个module进行正则，这都能够本人筛选，不用对每一个module都正则。 优化器中增加一个是Adam或者AdamW优化器外面有weight_decay参数，那个是l2的正则系数

我自己是此作者：https://yonggie.blog.csdn.net... 前言数学中（教科书、大学课堂、数学相干的科普视频），一个矩阵的向量往往是竖着的，一列作为一个vector，这一点numpy库也是这样默认的。然而在机器学习以torch框架为例，一个有意义的向量或者说embedding是横着的。 比拟因为numpy库默认是一列是一个向量而torch等机器学习框架默认一行是一个向量，所以torch.cov(X)和numpy.cov(X.T)是相等的。 自行实现torch在较高版本中才有torch.cov函数，低版本的须要自行实现。因为大部分博客都是数学格调的，在减掉均值后，大部分写$XX^T$算协方差矩阵，这是默认以列为一个vector，肯定要留神。因为torch的一个向量是一个横行，所以自行实现其实是$X^TX$ def torch_cov(input_vec:torch.tensor): x = input_vec- torch.mean(input_vec,axis=0) cov_matrix = torch.matmul(x.T, x) / (x.shape[0]-1) return cov_matrix这样子能够和numpy的cov比拟一下： vecs=torch.tensor([[1,2,3,4],[2,2,3,4]]).float()vecs_np=vecs.numpy()cov = np.cov(vecs_np.T)# 显示array([[0.5, 0. , 0. , 0. ], [0. , 0. , 0. , 0. ], [0. , 0. , 0. , 0. ], [0. , 0. , 0. , 0. ]])torch_cov(vecs)# 显示tensor([[0.5000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000]])二者是一样的。 直面矩阵的数学解释对于矩阵\(M\)来说，1行为一个高维变量\(x_i\)该当示意成 ...

背景我想要对一个大批量的数据分批输出模型失去所有的embedding，然而过程进行到两头报 cuda out of memory。经查勘是因为早些的embedding没有及时从cuda中开释内存导致前面的model无奈进行forward。 解决只须要pytorch的tensor.cpu()就能够开释了。举个例子： embeddings=[]for batch in data_loader: embedding_batch=model(input_data) embeddings.append(embedding_batch.cpu()) # 不带cpu不能开释cuda内存，导致oom若不加cpu()，会进行20多batch后cuda out of memory。 后记其实接触torch tensor曾经四年无余，往往对其cpu()是因为torch与numpy数据不合乎，往往和numpy()一起连用，本认为是对原tensor返回一个cpu device上的tensor，不扭转原变量，没想到cpu()居然是对原变量间接坐内存的变动，出其不意。

Pytorch模型保留与提取Pytorch模型保留与提取本篇笔记次要对应于莫凡Pytorch中的3.4节。次要讲了如何应用Pytorch保留和提取咱们的神经网络。在Pytorch中，网络的存储次要应用torch.save函数来实现。咱们将通过两种形式展现模型的保留和提取。第一种保留形式是保留整个模型，在从新提取时间接加载整个模型。第二种保留办法是只保留模型的参数，这种形式只保留了参数，而不会保留模型的构造等信息。两种形式各有优缺点。 保留残缺模型不须要晓得网络的构造，一次性保留一次性读入。毛病是模型比拟大时耗时较长，保留的文件也大。而只保留参数的形式存储快捷，保留的文件也小一些，但毛病是失落了网络的构造信息，复原模型时须要提前建设一个特定构造的网络再读入参数。以下应用代码展现。 数据生成与展现import torchimport torch.nn.functional as Fimport matplotlib.pyplot as plt复制代码这里还是生成一组带有噪声的y=x2y=x^{2}y=x2数据进行回归拟合。 # torch.manual_seed(1) # reproducible# fake datax = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) # x data (tensor), shape=(100, 1)y = x.pow(2) + 0.2*torch.rand(x.size()) # noisy y data (tensor), shape=(100, 1)复制代码 根本网络搭建与保留咱们应用nn.Sequential模块来疾速搭建一个网络实现回归操作，网络由两层Linear层和两头的激活层ReLU组成。咱们设置输入输出的维度为1，两头暗藏层变量的维度为10，以放慢训练。这里应用两种形式进行保留。 def save(): # save net1 net1 = torch.nn.Sequential( torch.nn.Linear(1, 10), torch.nn.ReLU(), torch.nn.Linear(10, 1) ) optimizer = torch.optim.SGD(net1.parameters(), lr=0.5) loss_func = torch.nn.MSELoss() for step in range(100): prediction = net1(x) loss = loss_func(prediction, y) optimizer.zero_grad() loss.backward() optimizer.step() # plot result plt.figure(1, figsize=(10, 3)) plt.subplot(131) plt.title('Net1') plt.scatter(x.data.numpy(), y.data.numpy()) plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5) plt.savefig("./img/05_save.png") torch.save(net1, 'net.pkl') # entire network torch.save(net1.state_dict(), 'net_params.pkl') # parameters复制代码在这个save函数中，咱们首先应用nn.Sequential模块构建了一个根底的两层神经网络。而后对其进行训练，展现训练后果。之后应用两种形式进行保留。第一种形式间接保留整个网络，代码为 ...

随着 5G 的倒退利用，人们对音视频通信的品质要求在一直进步。习惯了高清视觉享受的用户，显然无奈承受退回“马赛克时代”。关注【融云寰球互联网通信云】理解更多 然而，在寰球互联网通信云服务中，面对网络和终端的丰盛多样和复杂多变，又不免遇到用户带宽有余的状况。应用技术手段来进步图像和视频分辨率，让用户在较低带宽的状况下仍然取得较高清晰度的图像和视频就十分重要了。 本文分享应用图像超分辨率技术在无限带宽下实现 WebRTC 高清视频传输的优化计划。 视频编码中影响视频清晰度的次要因素实践上，对于同一种编码器而言，在分辨率不变的前提下，码率越大，视频品质越高。然而从视觉来看，在特定编码器和分辨率的状况下，码率存在一个最优值。 通常，视频通话/会议采纳的视频压缩计划为 H264 或者 VP8。在 H264 编码中，720P 和 1080P 的视频举荐码率为别离为 3500Kbps 和 8500Kbps。 在挪动设施中，H264 编码器举荐的码率如下表。 1280 x 7201920 x 1080极低码率500 Kbps1 Mbps低码率1 Mbps2 Mbps中等码率2 Mbps4 Mbps高码率4 Mbps8 Mbps极高码率8 Mbps16 Mbps（挪动端不同分辨率的举荐码率） 由上表可知，在 WebRTC 技术计划框架下进行视频通话时，采纳 H264 编码器对 1080P 高清视频进行压缩，视频若设定为中等码率则须要 4Mbps。 对于带宽有余的局部终端用户，若依然播放 1080P 的视频会存在卡顿的状况。则能够在 WebRTC 的技术框架下，采纳联播（simulcast）或者 SVC 的形式，对不同的终端用户依据各自的特点传输不同分辨率或者不同帧率的码流。 简略来说，若用户的网络环境不适宜传输 1080P 的视频，则给用户发送 720P 的视频，所需码率为 1080P 的一半，能够最大限度保障无限带宽下的视频传输流畅性。 高清已成趋势，在不扭转编码器即 H264 或 VP8 的状况下，如何仍然在终端上取得高清视频成为学术界和产业界须要独特钻研和解决的课题。 图像超分辨率技术在 WebRTC 中的利用图像超分辨率技术（Super Resolution，SR）是计算机视觉中进步图像和视频分辨率的重要技术，能够将一幅低分辨率图像重建出高分辨率图像。 ...

CA-IS1200器件是为基于分流电阻的电流检测而优化的高精度隔离式运放。 低的失调和增益误差以及相干温漂可能在全工作温度范畴内放弃测量的精度。 CA-IS1200器件采纳二氧化硅（SiO2）作为隔离层，反对合乎UL 1577认证的高达3750 VRMS的电气隔离。 该技术将高低压域离开从而避免低压器件被损坏，同时提供低辐射和高磁场抗扰度。高共模瞬态抗扰度（CMTI） 意味着CA-IS1200器件在隔离层之间正确地传递信号，适宜要求低压、大功率开关的工业电机管制和驱动利用场合。 器件外部输出共模过压和高边电源失落检测性能有助于故障诊断和系统安全。 CA-IS1200器件通过八脚DUB封装 ，反对在额外扩大工业温度范畴内（–40°C 到125°C）失常工作。 利用• 工业电机管制和驱动 • 隔离式开关电源 • 不间断电源 个性• 差分输出电压范畴：±250 mV • 固定初始增益：8 • 低输出失调和温漂：25°C时±0.2 mV，±4 V/°C • 低增益误差和温漂： 25°C时±0.3%，±50 ppm/°C • 低非线性度和温漂： 额外范畴内0.03%，±1 ppm/°C • 高边和低边均反对3.3 V和5 V供电电压 • 高共模瞬态抗扰度：±150 kV/µs（典型值） • 宽工作温度范畴：–40°C到125°C • 平安和法规认证（申请中） ▪ 合乎 DIN V VDE V 0884-11 (VDE V 0884-11): 2017-01规范的5300 VPK隔离耐压 ▪ 合乎UL 1577 认证， 1 分钟 3750 VRMS ▪ CQC和TUV相干认证 • 额外工作电压下使用寿命大于40年 ...

作者：Yashal Kanungo – 利用科学家，Kamran Khan – 高级技术产品经理，Shubha Kumbadakone – ML 框架高级专家 亚马逊广告应用 PyTorch、TorchServe 和 AWS Inferentia 将推理老本升高 71% 的同时推动横向扩大。 亚马逊广告（Amazon Ads）通过在亚马逊商店内外展现的广告（包含超过 15 个国家/地区的网站、利用和流媒体电视内容）帮忙公司建设品牌并与购物者建立联系。 各种规模的企业和品牌，包含注册卖家、供应商、图书供应商、Kindle Direct Publishing (KDP) 作者、应用程序开发人员和代理机构都能够上传本人的广告创意，其中能够包含图像、视频、音频，当然，还有在亚马逊上销售的商品。 为了推广精确、平安和愉悦的购物体验，这些广告必须恪守内容准则。 例如，广告闪动关上或敞开，产品必须在适当的上下文中展现，图片和文字应适宜一般受众。为了帮忙确保广告合乎所需的政策和规范，咱们须要开发可扩大的机制和工具。 作为解决方案，咱们应用机器学习 （ML） 模型来展现可能须要批改的广告。随着深度神经网络在过来十年中蓬勃发展，咱们的数据迷信团队开始摸索更通用的深度学习 (DL) 办法，这些办法可能以起码的人工干预解决文本、图像、音频或视频。为此，咱们应用PyTorch构建了计算机视觉（CV）和自然语言解决（NLP）模型，这些模型会主动标记可能不合规的广告。PyTorch 直观，灵便且用户敌对，并且曾经使咱们无缝过渡到应用 DL 模型。在基于 AWS Inferentia 的 Amazon EC2 Inf1 实例而不是基于 GPU 的实例上部署这些新模型，对于雷同的工作负载，咱们的推理提早升高了 30%，推理老本升高了 71%。 向深度学习过渡咱们的机器学习零碎将经典模型与词嵌入配对以评估广告文本。 然而咱们的需要在一直变动，随着提交量的不断扩大，咱们须要一种足够灵便的办法来随着咱们的业务扩大。此外，咱们的模型必须疾速并在几毫秒内投放广告，以提供最佳的客户体验。 在过来的十年中，深度学习在许多畛域都十分风行，包含自然语言、视觉和音频。因为深度神经网络通过多层传输数据集——逐渐提取更高层次的特色——它们能够比经典的ML模型做出更轻微的推断。例如，深度学习模型能够回绝做出虚伪申明的广告，而不是简略地检测被禁止的语言。 此外，深度学习技术是可转移的——为一项工作训练的模型能够适应执行相干工作。例如，能够优化预训练的神经网络以检测图像中的对象，而后进行微调以辨认不容许在广告中显示的特定对象。 深度神经网络能够主动执行经典ML最耗时的两个步骤：特色工程和数据标记与须要探索性数据分析和手工设计特色的传统监督学习办法不同，深度神经网络间接从数据中学习相干特色。DL 模型还能够剖析非结构化数据，例如文本和图像，而无需 ML 中所需的预处理。深度神经网络能够无效地扩大更多数据，并且在波及大型数据集的应用程序中体现得特地好。 咱们抉择了 PyTorch 来开发咱们的模型，因为它帮忙咱们最大限度地进步了零碎的性能。借助于 PyTorch，咱们能够更好地为客户服务，同时利用 Python 最直观的概念。PyTorch 中的编程是面向对象的：它将处理函数与它们批改的数据组合在一起。因而，咱们的代码库是模块化的，咱们能够在不同的应用程序中重用代码片段。此外，PyTorch 的 Eager 模式容许循环和控制结构，因而模型中的操作更简单。Eager 模式能够很容易地对咱们的模型进行原型设计和迭代，并且咱们能够应用各种数据结构。这种灵活性有助于咱们疾速更新模型以满足一直变动的业务需要。 ...

JoJoGAN: One Shot Face Stylization. 只用一张人脸图片，就能学习其格调，而后迁徙到其余图片。训练时长只用 1~2 min 即可。 codepaper成果： 主流程： 本文分享了集体在本地环境（非 colab）实际 JoJoGAN 的整个过程。你也能够按照本文上手训练本人喜爱的格调。 筹备环境装置： AnacondaPyTorchconda create -n torch python=3.9 -yconda activate torchconda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch -y查看： $ python - <<EOFimport torch, torchvisionprint(torch.__version__, torch.cuda.is_available())EOF1.10.1 True筹备代码git clone https://github.com/mchong6/JoJoGAN.gitcd JoJoGANpip install tqdm gdown matplotlib scipy opencv-python dlib lpips wandb# Ninja is required to load C++ extensionswget https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-linux.zipsudo unzip ninja-linux.zip -d /usr/local/bin/sudo update-alternatives --install /usr/bin/ninja ninja /usr/local/bin/ninja 1 --force而后，将本文提供的几个 *.py 放进 JoJoGAN 目录，从这里获取： https://github.com/ikuokuo/st... 。 ...

PyTorch之具体显存占用剖析原始文档：https://www.yuque.com/lart/ug... 前言PyTorch 应用中，因为显卡显存是固定的，并且短期内难以进一步晋升，所以把握显存具体占用的细节有助于咱们写出更加高效的代码，甚至跑出更好的后果。 所以本文联合 Connolly 的文章 《PyTorch 显存机制剖析》 依照本人的需要进行了批改，同时梳理了 checkpoint 机制应用过程中的显存变换状况。 剖析间接看代码。正文中表明了特定的显存占用和参数数量。 首先导入相干的包： import torchfrom torch.utils.checkpoint import checkpoint初始化必要的数据和构造： initial_usage = torch.cuda.memory_allocated()print("0", initial_usage) # 0# 模型初始化linear1 = torch.nn.Linear(1024, 1024, bias=False).cuda()after_init_linear1 = torch.cuda.memory_allocated()print("1", after_init_linear1 - initial_usage, linear1.weight.numel()) # 4194304 1048576linear2 = torch.nn.Sequential(torch.nn.Linear(1024, 1024, bias=False), torch.nn.Linear(1024, 1, bias=False)).cuda()after_init_linear2 = torch.cuda.memory_allocated()print("2", after_init_linear2 - after_init_linear1, sum([m.weight.numel() for m in linear2])) # 4198400 1049600# 输出定义inputs = torch.randn(size=(1024, 1024), device="cuda:0")after_init_inputs = torch.cuda.memory_allocated()print("3", after_init_inputs - after_init_linear2, inputs.numel()) # 4194304 1048576第一次迭代： ...

监督学习是训练机器学习模型的传统办法，它在训练时每一个察看到的数据都须要有标注好的标签。如果咱们有一种训练机器学习模型的办法不须要收集标签，会怎么样?如果咱们从收集的雷同数据中提取标签呢?这种类型的学习算法被称为自监督学习。这种办法在自然语言解决中工作得很好。一个例子是BERT¹，谷歌自2019年以来始终在其搜索引擎中应用BERT¹。可怜的是，对于计算机视觉来说，状况并非如此。 Facebook AI的kaiming大神等人提出了一种带掩码自编码器(MAE)²，它基于(ViT)³架构。他们的办法在ImageNet上的体现要好于从零开始训练的VIT。在本文中，咱们将深入研究他们的办法，并理解如何在代码中实现它。 带掩码自编码器(MAE)对输出图像的patches进行随机掩码，而后重建缺失的像素。MAE基于两个外围设计。首先，开发了一个非对称的编码器-解码器架构，其中编码器仅对可见的patches子集(没有掩码的tokens)进行操作，同时还有一个轻量级的解码器，能够从潜在示意和掩码tokens重建原始图像。其次，发现对输出图像进行高比例的掩码，例如75%，会产生有意义的自监督工作。将这两种设计联合起来，可能高效地训练大型模型：放慢模型训练速度(3倍甚至更多)并进步精度。 此阶段称为预训练，因为 MAE 模型稍后将用于上游工作，例如图像分类。模型在pretext上的体现在自监督中并不重要， 这些工作的重点是让模型学习一个预期蕴含良好语义的两头示意。在预训练阶段之后，解码器将被多层感知器 (MLP) 头或线性层取代，作为分类器输入对上游工作的预测。 模型架构编码器 编码器是 ViT。它承受张量形态为 (batch_size, RGB_channels, height, width) 的图像。通过执行线性投影为每个Patch取得嵌入， 这是通过 2D 卷积层来实现。而后张量在最初一个维度被展平（压扁），变成 (batch_size, encoder_embed_dim, num_visible_patches)，并 转置为形态（batch_size、num_visible_patches、encoder_embed_dim）的张量。 class PatchEmbed(nn.Module): """ Image to Patch Embedding """ def __init__(self, img_size=(224, 224), patch_size=(16, 16), in_chans=3, embed_dim=768): super().__init__() self.img_size = img_size self.patch_size = patch_size self.num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) self.patch_shape = (img_size[0] // patch_size[0], img_size[1] // patch_size[1]) self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) def forward(self, x, **kwargs): B, C, H, W = x.shape assert H == self.img_size[0] and W == self.img_size[1], f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." x = self.proj(x).flatten(2).transpose(1, 2) return x正如原始 Transformer 论文中提到的，地位编码增加了无关每个Patch地位的信息。作者应用“sine-cosine”版本而不是可学习的地位嵌入。上面的这个实现是一维版本。 ...

联邦学习也称为协同学习，它能够在产生数据的设施上进行大规模的训练，并且这些敏感数据保留在数据的所有者那里，本地收集、本地训练。在本地训练后，地方的训练协调器通过获取散布模型的更新取得每个节点的训练奉献，然而不拜访理论的敏感数据。 联邦学习自身并不能保障隐衷（稍后咱们将探讨联邦学习零碎中的隐衷毁坏和修复），但它的确使隐衷成为可能。 联邦学习的用例： 手机输入法的下一个词预测（e.g. McMahan et al. 2017, Hard et al. 2019）衰弱钻研（e.g. Kaissis et al. 2020, Sadilek et al. 2021）汽车主动驾驶（e.g. Zeng et al. 2021, OpenMined 的文章）“智能家居”零碎（e.g. Matchi et al. 2019, Wu et al. 2020）因为隐衷的问题所以对于集体来说，人们宁愿放弃他们的集体数据，也不会将数据提供给平台（平台有时候也想着白嫖），所以联邦学习简直涵盖了所有以集体为单位进行预测的所有场景。 随着公众和政策制定者越来越意识到隐衷的重要性，数据实际中对爱护隐衷的机器学习的需要也正在回升，对于数据的拜访受到越来越多的审查，对联邦学习等尊重隐衷的工具的钻研也越来越沉闷。在现实状况下，联邦学习能够在爱护集体和机构的隐衷的前提下，使数据利益相关者之间的单干成为可能，因为以前商业秘密、私人衰弱信息或数据泄露危险的通常使这种单干变得艰难甚至无奈进行。 欧盟《通用数据保护条例》或《加利福尼亚消费者隐衷法》等政府法规使联邦学习等隐衷爱护策略成为心愿放弃非法经营的企业的有用工具。与此同时，在放弃模型性能和效率的同时取得所需的隐衷和平安水平，这自身就带来了大量技术挑战。 从集体数据生产者（咱们都是其中的一员）的日常角度来看，至多在实践上是能够在私人衰弱和财务数据之间搁置一些货色来屏蔽那种跟踪你在网上行为设置裸露你的个人隐私的所谓的大杂烩生态系统。 如果这些问题中的任何一个引起你的共鸣，请持续浏览以理解更多对于联邦学习的复杂性以及它能够为应用敏感数据的机器学习做了哪些工作。 联邦学习简介联邦学习的目标是训练来自多个数据源的单个模型，其约束条件是数据停留在数据源上，而不是由数据源(也称为节点、客户端)替换，也不是由地方服务器进行编排训练(如果存在的话)。 在典型的联邦学习计划中，地方服务器将模型参数发送到各节点（也称为客户端、终端或工作器）。节点针对本地数据的一些训练初始模型，并将新训练的权重发送回地方服务器，地方服务器对新模型参数求平均值（通常与在每个节点上执行的训练量无关）。在这种状况下，地方服务器或其余节点永远不会间接看到任何一个其余节点上的数据，并应用平安聚合等附加技术进一步加强隐衷。 该框架内有许多变体。例如，在本文中次要关注由地方服务器治理的联邦学习计划，该计划在多个雷同类型的设施上编排训练，节点上每次训练都应用本人的本地数据并将后果上传到地方服务器，这是在 2017 年由 McMahan 等人形容的根本计划。然而某些状况下可能须要勾销训练的集中控制，当单个节点调配地方管理器的角色时，它就变成了去中心化的联邦学习，这是针对非凡的医疗数据训练模型的一种无效的解决方案。 典型的联邦学习场景可能波及大量的设施（例如手机），所有手机的计算能力大抵类似，训练雷同的模型架构。但有一些计划，例如Diao等人2021年提出的HeteroFL容许在具备微小差别的通信和计算能力的各种设施上训练一个繁多的推理模型，甚至能够训练具备不同架构和参数数量的部分模型，而后将训练的参数汇集到一个全局推理模型中。 联邦学习还有一个劣势是数据保留在产生数据的设施上，训练数据集通常比模型要大得多，因而发送后者而不是前者能够节俭带宽。 但在这些劣势中最重要的还是隐衷爱护，尽管有可能仅通过模型参数更新就推断出对于公有数据集内容的某些内容。McMahan等人在2017年应用了一个简略的例子来解释该破绽，即应用一个“词袋”输出向量训练的语言模型，其中每个输出向量具体对应于一个大词汇表中的一个单词。对于相应单词的每个非零梯度更新将为窃听者提供一个对于该单词在公有数据集中存在(反之亦然)的线索，还有更简单的攻打也被证实了。为了解决这个问题，能够将多种隐衷加强技术整合到联邦学习中，从平安的更新聚合到应用齐全同态加密进行训练。上面咱们将简要介绍联邦学习中对隐衷的最突出的威逼及其缓解措施。 国家对数据隐衷的监管是一个新兴的政策畛域，然而要比基于集体数据收集和剖析的倒退要晚10到20年。2016年颁布的《欧洲个别数据保护条例》(European General data Protection regulation，简称GDPR)是最重要的对于公众集体数据的法规，这可能会有些奇怪,因为相似的爱护限度企业监测和数据收集的措施施尚处于起步阶段甚至是没有。 两年后的2018年，加州消费者隐衷法案紧随欧盟的GDPR成为法律。作为一项州法律，与GDPR相比，CCPA在天文范畴上显著受到限制，该法案对个人信息的定义更窄。 联邦学习的名字是由McMahan等人在2017年的一篇论文中引入的，用来形容扩散数据模型的训练。作者依据2012年白宫对于消费者数据隐衷的报告为他们的零碎制订了设计策略。他们提出了联邦学习的两个次要用例:图像分类和用于语音辨认或下一个单词/短语预测的语言模型。 不久以后与分布式训练相干的潜在攻打就相继的呈现了。Phong et al. 2017和Bhowmick et al. 2018等人的工作表明，即便只拜访从联邦学习客户端返回到服务器的梯度更新或局部训练的模型，也能够推断出一些形容私人数据的细节。在inphero的文章中，你能够看到对于隐衷问题的总结和解决办法。 在联邦学习中，隐衷、有效性和效率之间的均衡波及宽泛的畛域。服务器和客户机之间的通信(或者仅仅是去中心化客户机之间的通信)能够在传输时进行加密，但还有一个更强壮的选项即在训练期间数据和模型也放弃加密。同态加密可用于对加密的数据执行计算，因而(在现实状况下)输入只能由持有密钥的涉众解密。OpenMined的PySyft、Microsoft的SEAL或TensorFlow Encrypted等库为加密的深度学习提供了工具，这些工具能够利用到联邦学习零碎中。 对于联邦学习的介绍到此为止，接下来咱们将在教程局部中设置一个简略的联邦学习演示。 联邦学习代码实现既然咱们曾经晓得在何处以及为什么要应用联邦学习，那么让咱们入手看看咱们如何这样做，在这里咱们应用鸢尾花数据集进行联邦学习。 有许多联邦学习库可供选择，从在 GitHub 上领有超过 1700 颗星的更支流的 Tensorflow Federated 到风行且重视隐衷的 PySyft，再到面向钻研的 FedJAX。上面表中蕴含风行的联邦学习存储库的参考列表。 ...

 欢送关注我的公众号 [极智视界]，回复001获取Google编程标准 O_o >_<  o_O O_o ~_~ o_O 本文记录了 pytorch 与 darknet 计算卷积输入 shape 形式比照，两者有一些区别。   卷积算子是深度学习中最罕用的算子，在神经网络中，往往须要波及到算子 shape 形态的推导，这里次要说一下 cov 层的 shape 推导，拿 pytorch 和 darknet 进行比照。 1、pytorch 卷积输入 shape 推导   看源码，答案在 torch/nn/modules/conv.py 脚本 class Conv2d(_ConvNd) 类的正文中： Shape: - Input: :math:`(N, C_{in}, H_{in}, W_{in})` - Output: :math:`(N, C_{out}, H_{out}, W_{out})` where .. math:: H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[0] - \text{dilation}[0] \times (\text{kernel\_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor .. math:: W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[1] - \text{dilation}[1] \times (\text{kernel\_size}[1] - 1) - 1}{\text{stride}[1]} + 1\right\rfloor 以上的计算公式为 LaTeX 格局，这是一种基于 TEX 的排版系统，由美国计算机学家莱斯利-兰伯特创造，利用这种格局，可能疾速生成简单表格和数学公式。不过这种格局对于咱们来说可读性比拟差，这里用富本编辑器的 公式 性能转换一下，来看 H_{out}： ...

本我的项目将应用Pytorch，实现一个简略的的音频信号分类器，可利用于机械信号分类辨认，鸟叫声信号辨认等利用场景。 我的项目应用librosa进行音频信号处理，backbone应用mobilenet_v2，在Urbansound8K数据上，最终收敛的准确率在训练集99%，测试集82%，如果想进一步提高辨认准确率能够应用更重的backbone和更多的数据加强办法。 残缺的我的项目代码：https://download.csdn.net/dow... 目录 我的项目构造环境配置3.数据处理 （1）数据集Urbansound8K （2）自定义数据集 （3）音频特征提取: 4.训练Pipeline 5.预测demo.py 我的项目构造环境配置应用pip命令装置libsora和pyaudio,pydub等库3.数据处理（1）数据集Urbansound8K Urbansound8K是目前利用较为宽泛的用于主动城市环境声分类钻研的公共数据集，蕴含10个分类：空调声、汽车鸣笛声、儿童游玩声、狗叫声、钻孔声、引擎空转声、枪声、手提钻、警笛声和街道音乐声。数据集下载：https://www.ctocio.com/?s=%E9... （2）自定义数据集能够本人录制音频信号，制作本人的数据集，参考[audio/dataloader/record_audio.py]每个文件夹寄存一个类别的音频数据，每条音频数据长度在3秒左右,倡议每类的音频数据平衡生产train和test数据列表：参考[audio/dataloader/create_data.py] （3）音频特征提取: 音频信号是一维的语音信号，不能间接用于模型训练，须要应用librosa将音频转为梅尔频谱（Mel Spectrogram）。 librosa提供python接口，在音频、噪音信号的剖析中常常用到 wav, sr = librosa.load(data_path, sr=16000) 应用librosa取得音频的梅尔频谱spec_image = librosa.feature.melspectrogram(y=wav, sr=sr, hop_length=256)对于librosa的应用办法，请参考： 音频特征提取——librosa工具包应用 梅尔频谱(mel spectrogram)原理与应用 4.训练Pipeline（1）构建训练和测试数据 def build_dataset(self, cfg): """构建训练数据和测试数据""" input_shape = eval(cfg.input_shape) # 获取数据 train_dataset = AudioDataset(cfg.train_data, data_dir=cfg.data_dir, mode='train', spec_len=input_shape[3]) train_loader = DataLoader(dataset=train_dataset, batch_size=cfg.batch_size, shuffle=True, num_workers=cfg.num_workers) test_dataset = AudioDataset(cfg.test_data, data_dir=cfg.data_dir, mode='test', spec_len=input_shape[3]) test_loader = DataLoader(dataset=test_dataset, batch_size=cfg.batch_size, shuffle=False, num_workers=cfg.num_workers) print("train nums:{}".format(len(train_dataset))) print("test nums:{}".format(len(test_dataset))) return train_loader, test_loader因为librosa.load加载音频数据特地慢，倡议应用cache先进行缓存，不便减速 ...

CoursePyTorch模型推理及多任务通用范式 课程5: 给大家安利了大白老师之前的好文：对于Yolo系列算法的理论知识解读和实战训练代码。依据 pytorch模型推理的三板斧：数据预处理、数据进网络、数据后处理，逐行实现了Yolox的推理代码。Assignment必做题本人找2张其余图，用Yolox_s进行指标检测，并注明输出尺寸和两个阈值。思考题Yolox_s：用time模块和for循环，对”./images/1.jpg”间断推理100次，统计工夫开销。有CUDA的同学，改下代码：self.device=torch.device('cuda')，统计工夫开销。有CUDA的同学，别离用 Yolox_tiny、Yolox_s、Yolox_m、Yolox_l、Yolox_x 对”./images/1.jpg”间断推理100次，统计工夫开销。SolutionsCodeimport torchimport torch.nn as nnimport torchvisionimport numpy as npimport cv2from models_yolox.visualize import visfrom models_yolox.yolo_head import YOLOXHeadfrom models_yolox.yolo_pafpn import YOLOPAFPNimport time# write output imagedef write_output(result, image, output): if result is not None: bboxes, scores, labels = result image = vis(image, bboxes, scores, labels, label_names) text1 = 'image size : {}*{}'.format(model_detect.w, model_detect.h) text2 = 'conf threshold : {}'.format(model_detect.conf_threshold) text3 = 'nms threshold : {}'.format(model_detect.nms_threshold) font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(image, text1, (10, 20), font, 0.7, (0, 255, 0), 1, cv2.LINE_AA) cv2.putText(image, text2, (10, 50), font, 0.7, (0, 255, 0), 1, cv2.LINE_AA) cv2.putText(image, text3, (10, 80), font, 0.7, (0, 255, 0), 1, cv2.LINE_AA) cv2.imwrite(output, image)# run a model multiple timesdef run_evl(times, model, device, image): image = cv2.imread(image) # CPU run 100 times model_detect = ModelPipline(device=device, model_name=model) t_all=0 for i in range(times): t_start = time.time() model_detect.predict(image) t_end = time.time() t_all += t_end - t_start print('{} run model {} {} time lapse: {:.4f} seconds.'.format(device, model, times, t_all))class YOLOX(nn.Module): def __init__(self, num_classes, depth=0.33, width=0.5, in_channels=[256, 512, 1024]): super().__init__() #yolox_s by default self.backbone = YOLOPAFPN(depth=depth, width=width, in_channels=in_channels) self.head = YOLOXHead(num_classes=num_classes, width=width, in_channels=in_channels) def forward(self, x): fpn_outs = self.backbone(x) outputs = self.head(fpn_outs) return outputsclass ModelPipline(object): def __init__(self, device=torch.device('cuda'), model_name='yolox_s'): # 进入模型的图片大小：为数据预处理和后处理做筹备 self.inputs_size = (640, 640) # (h,w) # CPU or CUDA：为数据预处理和模型加载做筹备 self.device = device # 后处理的阈值 self.conf_threshold = 0.5 self.nms_threshold = 0.4 # 标签载入 label_names = open('./labels/coco_label.txt', 'r').readlines() self.label_names = [line.strip('\n') for line in label_names] # image size self.w = 0 self.h = 0 # for model selection self.model_info = { 'yolox_tiny': [0.33, 0.375, './weights/yolox_tiny_coco.pth.tar'], 'yolox_s': [0.33, 0.5, './weights/yolox_s_coco.pth.tar'], 'yolox_m': [0.67, 0.75, './weights/yolox_m_coco.pth.tar'], 'yolox_l': [1.0, 1.0, './weights/yolox_l_coco.pth.tar'], 'yolox_x': [1.33, 1.25, './weights/yolox_x_coco.pth.tar'], } # 载入模型构造和模型权重 self.num_classes = 80 self.model = self.get_model(model_name) def predict(self, image): # 数据预处理 inputs, r = self.preprocess(image) # 数据进网络 outputs = self.model(inputs) # 数据后处理 results = self.postprocess(outputs, r) return results def get_model(self, model_name): model_info = self.model_info[model_name] depth = model_info[0] width = model_info[1] path = model_info[2] if model_name == 'yolox_tiny': self.inputs_size = (416, 416) model = YOLOX(self.num_classes, depth, width) pretrained_state_dict = torch.load(path, map_location=lambda storage, loc: storage)["model"] model.load_state_dict(pretrained_state_dict, strict=True) model.to(self.device) model.eval() return model def preprocess(self, image): # 原图尺寸 h, w = image.shape[:2] # to print image size self.h = h self.w = w # 生成一张 w=h=640的mask，数值全是114 padded_img = np.ones((self.inputs_size[0], self.inputs_size[1], 3)) * 114.0 # 计算原图的长边缩放到640所须要的比例 r = min(self.inputs_size[0] / h, self.inputs_size[1] / w) # 对原图做等比例缩放，使得长边=640 resized_img = cv2.resize(image, (int(w * r), int(h * r)), interpolation=cv2.INTER_LINEAR).astype(np.float32) # 将缩放后的原图填充到 640×640的mask的左上方 padded_img[: int(h * r), : int(w * r)] = resized_img # BGR——>RGB padded_img = padded_img[:, :, ::-1] # 归一化和标准化，和训练时保持一致 inputs = padded_img / 255 inputs = (inputs - np.array([0.485, 0.456, 0.406])) / np.array([0.229, 0.224, 0.225]) ##以下是图像工作的通用解决 # (H,W,C) ——> (C,H,W) inputs = inputs.transpose(2, 0, 1) # (C,H,W) ——> (1,C,H,W) inputs = inputs[np.newaxis, :, :, :] # NumpyArray ——> Tensor inputs = torch.from_numpy(inputs) # dtype float32 inputs = inputs.type(torch.float32) # 与self.model放在雷同硬件上 inputs = inputs.to(self.device) return inputs, r def postprocess(self, prediction, r): # prediction.shape=[1,8400,85]，上面先将85中的前4列进行转换，从 xc,yc,w,h 变为 x0,y0,x1,y1 box_corner = prediction.new(prediction.shape) box_corner[:, :, 0] = prediction[:, :, 0] - prediction[:, :, 2] / 2 box_corner[:, :, 1] = prediction[:, :, 1] - prediction[:, :, 3] / 2 box_corner[:, :, 2] = prediction[:, :, 0] + prediction[:, :, 2] / 2 box_corner[:, :, 3] = prediction[:, :, 1] + prediction[:, :, 3] / 2 prediction[:, :, :4] = box_corner[:, :, :4] # 只解决单张图 image_pred = prediction[0] # class_conf.shape=[8400,1],求每个anchor在80个类别中的最高分数。class_pred.shape=[8400,1],每个anchor的label index。 class_conf, class_pred = torch.max(image_pred[:, 5: 5 + self.num_classes], 1, keepdim=True) conf_score = image_pred[:, 4].unsqueeze(dim=1) * class_conf conf_mask = (conf_score >= self.conf_threshold).squeeze() # detections.shape=[8400,6]，别离是 x0 ,y0, x1, y1, obj_score*class_score, class_label detections = torch.cat((image_pred[:, :4], conf_score, class_pred.float()), 1) # 将obj_score*class_score > conf_thre 筛选进去 detections = detections[conf_mask] # 通过阈值筛选后，如果没有残余指标则完结 if not detections.size(0): return None # NMS nms_out_index = torchvision.ops.batched_nms(detections[:, :4], detections[:, 4], detections[:, 5], self.nms_threshold) detections = detections[nms_out_index] # 把坐标映射回原图 detections = detections.data.cpu().numpy() bboxes = (detections[:, :4] / r).astype(np.int64) scores = detections[:, 4] labels = detections[:, 5].astype(np.int64) return bboxes, scores, labelsif __name__ == '__main__': model_detect = ModelPipline(torch.device('cuda'), 'yolox_s') label_names = model_detect.label_names # detect image 2 image = cv2.imread('./images/2.jpg') result = model_detect.predict(image) write_output(result, image, './demos/2.jpg') # detect image 3 image = cv2.imread('./images/3.jpg') result = model_detect.predict(image) write_output(result, image, './demos/3.jpg') # get time lapse of 100 iteration run_evl(100, 'yolox_s', torch.device('cpu'), './images/1.jpg') run_evl(100, 'yolox_tiny', torch.device('cuda'), './images/1.jpg') run_evl(100, 'yolox_s', torch.device('cuda'), './images/1.jpg') run_evl(100, 'yolox_m', torch.device('cuda'), './images/1.jpg') run_evl(100, 'yolox_l', torch.device('cuda'), './images/1.jpg') run_evl(100, 'yolox_x', torch.device('cuda'), './images/1.jpg')必做题提交2张图的检测成果，并注明输出尺寸和两个阈值。图一图二思考题CPU推理和CUDA推理，各自的工夫开销。运行后果：cpu run model yolox_s 100 time lapse: 13.2529 seconds.cuda run model yolox_s 100 time lapse: 3.6188 seconds.GPU显著比CPU运算快。不同Backbone各自的工夫开销。运行后果：cuda run model yolox_tiny 100 time lapse: 2.5452 seconds.cuda run model yolox_s 100 time lapse: 3.6188 seconds.cuda run model yolox_m 100 time lapse: 4.0251 seconds.cuda run model yolox_l 100 time lapse: 4.7148 seconds.cuda run model yolox_x 100 time lapse: 6.5571 seconds.模型越大工夫开销越大。学习心得这次课程对你的帮忙有哪些？技术上、学习办法上、思路上等都行，随便施展。很久没写过作业了，督促了我写点货色，相熟一下之前不器重的细节。推理通用范式有实用价值，后续能够用在试验代码里。对课程的优化改良有什么倡议？内容上、流程上、模式上等都行，随便施展。本课程给我的感觉是老师们很尽心，内容丰盛，解说分明，有播种。但限于文字的模式，看得出来一些常识老师想讲但没法讲。心愿当前能录视频对着画板写写画画的讲，这样老师讲的分明，学生学得明确。另外心愿授课内容和代码能更贴近生产一线，多一些业界实际，能带入一些偏日常工作可能遇到的问题去思考和解决是最好的了。最好能够附上本人所处的阶段，比方：学生，接触AI一年； 退职，3年AI我的项目教训 等。自己研一，接触深度学习不到一年，课题是机器视觉相干。

CoursePyTorch模型推理及多任务通用范式 课程3: pytorch模型推理的三板斧：数据预处理、数据进网络、数据后处理。其中 数据预处理要向训练时的预处理形式对齐；模型网络次要是加载预训练权重；数据后处理要向模型head构造和loss设计对齐。以MobileNet-v2为例，从头写了把模型推理。Assignment必做题把模型改为resnet18，加载相应的模型权重（Lesson2的物料包中有），跑一下0.jpg和1.jpg，看一下输入后果。官网torchvision训练mobilenet和训练resnet的形式是一样的，所以数据预处理和数据后处理局部完全相同。本人找2张其余图，用resnet18做下推理。思考题以ResNet18为例，用time模块和for循环，对”./images/0.jpg”间断推理100次，统计工夫开销，比方： import time model_classify=ModelPipline() image=cv2.imread("./images/0.jpg") t_all=0 for i in range(100): t_start=time.time() result=model_classify.predict(image) t_end=time.time() t_all+=t_end - t_start print(t_all) 有CUDA的同学，改下代码： self.device=torch.device('cuda')。用上述雷同办法测试工夫开销。 在数据预处理和数据后处理的代码实现中，到处在用numpy, opencv, torch 对数组做相应变换，大家至多要把课程中呈现的函数们给了解。SolutionsCodeimport torchimport torchvision.models as modelsimport numpy as npimport cv2import timeclass ModelPipline(object): def __init__(self, device=torch.device('cpu')): # 进入模型的图片大小：为数据预处理和后处理做筹备 self.inputs_size = (224, 224) # Add input parameter device self.device = device # 载入模型构造和模型权重 self.model = self.get_model() # 载入标签，为数据后处理做筹备 label_names = open('./labels/imagenet_label.txt', 'r').readlines() self.label_names = [line.strip('\n') for line in label_names] def predict(self, image): # 数据预处理 inputs = self.preprocess(image) # 数据进网络 outputs = self.model(inputs) # 数据后处理 results = self.postprocess(outputs) return results def get_model(self): # modified to load pytorch official weight model = models.resnet18(pretrained=True) model.to(self.device) model.eval() return model def preprocess(self, image): # opencv默认读入是BGR，须要转为RGB，和训练时保持一致 image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # resize成模型输出的大小，和训练时保持一致 image = cv2.resize(image, dsize=self.inputs_size) # 归一化和标准化，和训练时保持一致 inputs = image / 255 inputs = (inputs - np.array([0.485, 0.456, 0.406])) / np.array([0.229, 0.224, 0.225]) ##以下是图像工作的通用解决 # (H,W,C) ——> (C,H,W) inputs = inputs.transpose(2, 0, 1) # (C,H,W) ——> (1,C,H,W) inputs = inputs[np.newaxis, :, :, :] # NumpyArray ——> Tensor inputs = torch.from_numpy(inputs) # dtype float32 inputs = inputs.type(torch.float32) # 与self.model放在雷同硬件上 inputs = inputs.to(self.device) return inputs def postprocess(self, outputs): # 取softmax失去每个类别的置信度 outputs = torch.softmax(outputs, dim=1) # 取最高置信度的类别和分数 score, label_id = torch.max(outputs, dim=1) # Tensor ——> float score, label_id = score.item(), label_id.item() # 查找标签名称 label_name = self.label_names[label_id] return label_name, scoreif __name__ == '__main__': # config device device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model_classify = ModelPipline(device) image = cv2.imread('./images/0.jpg') result = model_classify.predict(image) print(result) image = cv2.imread('./images/1.jpg') result = model_classify.predict(image) print(result) image = cv2.imread('./images/2.jpg') result = model_classify.predict(image) print(result) image = cv2.imread('./images/3.jpg') result = model_classify.predict(image) print(result) # CPU: predict image 0.jpg 100 times image=cv2.imread("./images/0.jpg") device = torch.device('cpu') model_classify = ModelPipline(device) t_all=0 for i in range(100): t_start=time.time() result=model_classify.predict(image) t_end=time.time() t_all+=t_end - t_start print('CPU 100 time lapse: {:.4f} seconds.'.format(t_all)) # GPU: predict image 0.jpg 100 times device = torch.device('cuda') model_classify = ModelPipline(device) t_all=0 for i in range(100): t_start=time.time() result=model_classify.predict(image) t_end=time.time() t_all+=t_end - t_start print('GPU 100 time lapse: {:.4f} seconds.'.format(t_all))必做题提交下推理的输入后果（标签和置信度）。 ('umbrella', 0.9995710253715515) ('peacock', 0.9999837875366211)提交下找的2张图片，以及推理的输入后果。('geyser', 0.9999121427536011)('snorkel', 0.96727454662323) ...

Softmax 代码import torchimport torch.nn as nnsoftmax = nn.Softmax(dim=1) input = torch.randn(1, 10) output = softmax(input) print(output.size())torch.Size([1, 10]) 援用<1>torch=1.7.1+cu101torchvision=0.8.2torchaudio=0.7.2

全连贯层 代码import torchimport torch.nn as nnfc = nn.Linear(512, 10)input = torch.randn(1, 512, 1, 1)output = input.view(input.size(0), -1)output = fc(output)print(output.size())torch.Size([1, 10])援用<1>torch=1.7.1+cu101torchvision=0.8.2torchaudio=0.7.2

代码import torchimport torch.nn as nninput = torch.randn(1, 512, 1, 1)output = input.view(input.size(0), -1)print(output.size())torch.Size([1, 512])import torchimport torch.nn as nninput = torch.randn(1, 512, 1, 1)output = input.view(-1, input.size(0))print(output.size())torch.Size([512, 1])援用<1>torch=1.7.1+cu101torchvision=0.8.2torchaudio=0.7.2

2D最大池化 代码import torchimport torch.nn as nninput = torch.randn(1, 3, 224, 224)maxpooling2d = nn.MaxPool2d(3, 2)output = maxpooling2d(input)print(output.size())torch.Size([1, 3, 111, 111])import torchimport torch.nn as nninput = torch.randn(1, 3, 224, 224)maxpooling2d = nn.MaxPool2d(3, 2, 1)output = maxpooling2d(input)print(output.size())torch.Size([1, 3, 112, 112])援用<1>torch=1.7.1+cu101torchvision=0.8.2torchaudio=0.7.2

2D卷积 代码import torchimport torch.nn as nninput = torch.randn(1, 3, 112, 112)conv2d = nn.Conv2d(3, 64, (3, 3), 2, 1)output = conv2d(input)print(output.size())torch.Size([1, 64, 56, 56])援用<1>torch=1.7.1+cu101torchvision=0.8.2torchaudio=0.7.2<2>https://pytorch.org/docs/1.7....

作者｜Ta-Ying Cheng，牛津大学博士研究生，Medium技术博主，多篇文章均被平台官网刊物Towards Data Science收录翻译｜颂贤以往人们普遍认为生成图像是不可能实现的工作，因为依照传统的机器学习思路，咱们基本没有真值（ground truth）能够拿来测验生成的图像是否合格。 2014年，Goodfellow等人则提出生成反抗网络（Generative Adversarial Network, GAN），可能让咱们齐全依附机器学习来生成极为真切的图片。GAN的横空出世使得整个人工智能行业都为之触动，计算机视觉和图像生成畛域产生了巨变。 本文将带大家理解GAN的工作原理，并介绍如何通过PyTorch简略上手GAN。 GAN的原理依照传统的办法，模型的预测后果能够间接与已有的真值进行比拟。然而，咱们却很难定义和掂量到底怎么才算作是“正确的”生成图像。 Goodfellow等人则提出了一个乏味的解决办法：咱们能够先训练好一个分类工具，来主动辨别生成图像和实在图像。这样一来，咱们就能够用这个分类工具来训练一个生成网络，直到它可能输入齐全以假乱真的图像，连分类工具本人都没有方法评判虚实。 依照这一思路，咱们便有了GAN：也就是一个生成器（generator）和一个判断器（discriminator）。生成器负责依据给定的数据集生成图像，判断器则负责辨别图像是真是假。GAN的运作流程如上图所示。 损失函数在GAN的运作流程中，咱们能够发现一个显著的矛盾：同时优化生成器和判断器是很艰难的。能够设想，这两个模型有着齐全相同的指标：生成器想要尽可能伪造出实在的货色，而判断器则必须要识破生成器生成的图像。 为了阐明这一点，咱们设D(x)为判断器的输入，即x是实在图像的概率，并设G(z)为生成器的输入。判断器相似于一种二进制的分类器，所以其指标是使该函数的后果最大化：这一函数实质上是非负的二元穿插熵损失函数。另一方面，生成器的指标是最小化判断器做出正确判断的机率，因而它的指标是使上述函数的后果最小化。 因而，最终的损失函数将会是两个分类器之间的极小极大博弈，示意如下：实践上来说，博弈的最终后果将是让判断器判断胜利的概率收敛到0.5。然而在实践中，极大极小博弈通常会导致网络不收敛，因而认真调整模型训练的参数十分重要。 在训练GAN时，咱们尤其要留神学习率等超参数，学习率比拟小时能让GAN在输出乐音较多的状况下也能有较为对立的输入。 计算环境库本文将领导大家通过PyTorch搭建整个程序（包含torchvision）。同时，咱们将会应用Matplotlib来让GAN的生成后果可视化。以下代码可能导入上述所有库： """Import necessary libraries to create a generative adversarial networkThe code is mainly developed using the PyTorch library"""import timeimport torchimport torch.nn as nnimport torch.optim as optimfrom torch.utils.data import DataLoaderfrom torchvision import datasetsfrom torchvision.transforms import transformsfrom model import discriminator, generatorimport numpy as npimport matplotlib.pyplot as plt数据集数据集对于训练GAN来说十分重要，尤其思考到咱们在GAN中解决的通常是非结构化数据（个别是图片、视频等)，任意一class都能够有数据的散布。这种数据分布恰好是GAN生成输入的根底。 为了更好地演示GAN的搭建流程，本文将带大家应用最简略的MNIST数据集，其中含有6万张手写阿拉伯数字的图片。 像MNIST这样高质量的非结构化数据集都能够在格物钛的公开数据集网站上找到。事实上，格物钛Open Datasets平台涵盖了很多优质的公开数据集，同时也能够实现数据集托管及一站式搜寻的性能，这对AI开发者来说，是相当实用的社区平台。 硬件需要一般来说，尽管能够应用CPU来训练神经网络，但最佳抉择其实是GPU，因为这样能够大幅晋升训练速度。咱们能够用上面的代码来测试本人的机器是否用GPU来训练： """Determine if any GPUs are available"""device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')实现网络结构因为数字是非常简单的信息，咱们能够将判断器和生成器这两层构造都组建成全连贯层（fully connected layers）。 ...

内容导读 PyTorch 1.9 同步更新了一些库，包含 TorchVision 中新增的 SSD 和 SSDlite 模型，与 SSD 相比，SSDlite 更实用于挪动端 APP 开发。 SSD 全称 Single Shot MultiBox Detector，是一种用于指标检测的单次检测算法，每次能够检测多个物体。本文将重点探讨 SSD 的挪动端敌对型变体，即 SSDlite。 具体叙述过程为： 首先通过算法的次要组件，强调与原始 SSD 的不同之处； 而后探讨这个已公布的模型，是如何训练的； 最初为所有新上线的指标检测模型，提供具体的 Benchmark。 SSDlite 网络架构SSDlite 是 SSD 的升级版， 在 MobileNetV2 论文中首次公布，随后在 MobileNetV3 论文中被再次应用。因为这两篇论文的重点，是介绍新的 CNN 架构，所以 SSDlite 的大部分实现细节并没有提及。 咱们的代码遵循了这两篇论文中的所有细节，并在必要时对官网实现办法进行了补充。 正如前文所说，SSD 是一系列模型，用户能够用不同的 backbone（如 VGG、MobileNetV3 等）和不同的 Head（如惯例卷积、可拆散卷积等）来进行配置。因而，在 SSDlite 中，许多 SSD 组件都是雷同的。 上面咱们只探讨那些不同的局部。 分类和回归 Head依据 MobileNetV2 论文介绍，SSDlite 用可拆散卷积取代了原始 Head 中应用的惯例卷积。 因而，咱们的实现办法引入了应用 3x3 深度卷积和 1x1 投影的全新 Head。 ...

ECON 322: Econometric Analysis 1Final data project: Winter 2019General instructionsThis last assignment is due on Sunday April 7 before 11:30pm on Learn. It is a small research projectand you will be evaluated on your ability to correctly use the different concepts covered during theterm. It is approximately worth 3 assignments (8.5 points out of 25). The drop box will not close, soyou will be allowed to submit the project late. The rule for late submissions is as follows: if you arebetween 0.01 and 60 minutes late you get a 2/10 penalty, between 60.01 and 120 minutes late you get5/10 penalty, and you get a 10/10 penalty if you submit the project more than two hours late. Toavoid penalties, do not wait at the last minute to upload it. Notice that there is no justification fornot submitting this assignment (I remind you that doctor notes for being sick around the due date isnot accepted for assignments).For the final assignment, I want it to be organized like a report. I want the codes and R output alongwith the comments and discussion in the same pdf file. If you upload your document in any otherformat (.doc, .docx, ...), I will not mark it. If you want to see what I expect from you, download thedocument Assignment7 W17Sol.pdf that I uploaded in the folder “Final Project”. It is the suggestedsolution from Winter 2017 project. If you only put the codes and output with no discussion (onesentence it not considered a discussion), you get 0 out of 10 points. To obtain the full mark, you needto justify what you are doing (choice of the model, tests, etc.) analyze the results (interpretation ofthe coefficients, discussion about the validity of your results, etc.), and show me that you know howto use the different concepts used in class. The more concepts you use the higher will be your mark.The projectFor this project, we use the data “Fatalities” from the “AER” package. To get the data, install the“AER” package, then load the data using the following command:library(AER)data(Fatalities)The data frame will be called “Fatalities”. For a complete description of the variables, you can usethe help() function as follows:help(Fatalities)The main objective of the project is to measure the impact of different alcohol policies on carfatalities. As you will discover by looking at the help file, there are several measures of car fatalities.However, we assume that the same model can be used to explain any of the measure. You can thereforeselect the model independently from which car fatality measures is used on the left hand side. Youmay want to comment on that assumption. Do you think it is a reasonable assumption?You will see that all qualitative variables are expressed as factors. We have covered that in one ofyour tutorials, so you should be able to figure out how to deal with such format. For example, you canrun a regression of f atal on jail, which is “yes” or “no”, and let R create dummy variables for you:Econ 322 Final Project Page 1 of 5lm(fatal~jail, Fatalities) ...

如下程序 import torcha = torch.tensor(1.0, requires_grad=True)b = torch.tensor(1.0, requires_grad=True)print(a.grad)y = (a ** 2) * (b ** 3)z = y ** 100print(z)z.backward()print(a.grad.data)print(b.grad.data)将会打印 Nonetensor(1., grad_fn=<PowBackward0>)tensor(200.)tensor(300.)前向流传就是z的值是从a b计算y的值 再从y计算z的值反向流传就是从z对 a b的表达式中计算对应的偏导

SoftRas 是目前支流三角网格可微渲染器之一。 可微渲染通过计算渲染过程的导数，使得从单张图片学习三维构造逐步成为事实。可微渲染目前被宽泛地利用于三维重建，特地是人体重建、人脸重建和三维属性预计等利用中。 装置conda 装置 PyTorch 环境： conda create -n torch python=3.8 -yconda activate torchconda install pytorch torchvision torchaudio cudatoolkit=11.1 -c pytorch -c nvidia -yconda activate torchpython - <<-EOFimport platformimport torchprint(f"Python : {platform.python_version()}")print(f"PyTorch: {torch.__version__}")print(f" CUDA : {torch.version.cuda}")EOFPython : 3.8.10PyTorch: 1.9.0 CUDA : 11.1获取代码并装置： git clone https://github.com/ShichenLiu/SoftRas.gitcd SoftRaspython setup.py install可设 setup.py 镜像源： cat <<-EOF > ~/.pydistutils.cfg[easy_install]index_url = http://mirrors.aliyun.com/pypi/simpleEOF利用装置模型查看工具： snap install ogre-meshviewer# 或snap install meshlab渲染物体渲染测试： CUDA_VISIBLE_DEVICES=0 python examples/demo_render.py渲染后果： 比照前后模型: ogre-meshviewer data/obj/spot/spot_triangulated.objogre-meshviewer data/results/output_render/saved_spot.objMesh 重建下载数据集： ...

pytorch中的前向流传和反向流传 例如定义两个变量 import torcha = torch.tensor(1.0, requires_grad=True)b = torch.tensor(1.0, requires_grad=True)正向流传就是按输出计算对应的输入y = (a ** 2) * (b ** 3)z = y ** 100print(z)打印失去 tensor(1., grad_fn=<PowBackward0>)反向流传为 从输入往链式求导，直到计算到每个输出的偏导例如z对a和b的偏导为 $$100 * (a^{2} * b^{2})^{99} * 2 * a * b^{3}$$ $$100 * (a^{2} * b^{2})^{99} * a^{2} * 3 * b^{2}$$ 带入a和b的值1应该求出200 300，测试代码 z.backward()print(a.grad.data)print(b.grad.data)打印后果为 tensor(200.)tensor(300.)

装置anaconda（python3.6环境）下载 anaconda例如Anaconda3-5.2.0-Windows-x86_64.exe 装置时候配置设置环境变量 装置PyCharm（python的ide）下载链接 有收费的社区版创立PyCharm工程 抉择工程寄存的地位 conda环境的地位和版本创立之后能够应用命令conda env list :看到创立的环境activate xxx :激活xxx的环境conda install pytorch torchvision -c pytorch :装置pytorch 测试import torchprint("cuda is available:{}".format(torch.cuda.is_available()))

本文将利用 TorchVision Faster R-CNN 预训练模型，于 Kaggle: 寰球小麦检测 ???? 上实际迁徙学习中的一种罕用技术：微调（fine tuning）。 本文相干的 Kaggle Notebooks 可见： TorchVision Faster R-CNN FinetuningTorchVision Faster R-CNN Inference如果你没有 GPU ，也可于 Kaggle 上在线训练。应用介绍： Use Kaggle Notebooks那么，咱们开始吧 ???? 筹备数据import osimport numpy as npimport pandas as pdimport seaborn as snsfrom matplotlib import pyplot as pltfrom PIL import Image下载数据Kaggle: 寰球小麦检测 Data 页下载数据，内容如下： train.csv - the training datasample_submission.csv - a sample submission file in the correct formattrain.zip - training imagestest.zip - test imagesDIR_INPUT = 'global-wheat-detection'DIR_TRAIN = f'{DIR_INPUT}/train'DIR_TEST = f'{DIR_INPUT}/test'读取数据读取 train.csv 内容： ...

筹备数据筹备 COCO128 数据集，其是 COCO train2017 前 128 个数据。按 YOLOv5 组织的目录： $ tree ~/datasets/coco128 -L 2/home/john/datasets/coco128├── images│   └── train2017│   ├── ...│   └── 000000000650.jpg├── labels│   └── train2017│   ├── ...│   └── 000000000650.txt├── LICENSE└── README.txt详见 Train Custom Data。 定义 Datasettorch.utils.data.Dataset 是一个数据集的抽象类。自定义数据集时，需继承 Dataset 并笼罩如下办法： __len__: len(dataset) 获取数据集大小。__getitem__: dataset[i] 拜访第 i 个数据。详见： torch.utils.data.Datasettorchvision.datasets.vision.VisionDataset自定义实现 YOLOv5 数据集的例子： import osfrom pathlib import Pathfrom typing import Any, Callable, Optional, Tupleimport numpy as npimport torchimport torchvisionfrom PIL import Imageclass YOLOv5(torchvision.datasets.vision.VisionDataset): def __init__( self, root: str, name: str, transform: Optional[Callable] = None, target_transform: Optional[Callable] = None, transforms: Optional[Callable] = None, ) -> None: super(YOLOv5, self).__init__(root, transforms, transform, target_transform) images_dir = Path(root) / 'images' / name labels_dir = Path(root) / 'labels' / name self.images = [n for n in images_dir.iterdir()] self.labels = [] for image in self.images: base, _ = os.path.splitext(os.path.basename(image)) label = labels_dir / f'{base}.txt' self.labels.append(label if label.exists() else None) def __getitem__(self, idx: int) -> Tuple[Any, Any]: img = Image.open(self.images[idx]).convert('RGB') label_file = self.labels[idx] if label_file is not None: # found with open(label_file, 'r') as f: labels = [x.split() for x in f.read().strip().splitlines()] labels = np.array(labels, dtype=np.float32) else: # missing labels = np.zeros((0, 5), dtype=np.float32) boxes = [] classes = [] for label in labels: x, y, w, h = label[1:] boxes.append([ (x - w/2) * img.width, (y - h/2) * img.height, (x + w/2) * img.width, (y + h/2) * img.height]) classes.append(label[0]) target = {} target["boxes"] = torch.as_tensor(boxes, dtype=torch.float32) target["labels"] = torch.as_tensor(classes, dtype=torch.int64) if self.transforms is not None: img, target = self.transforms(img, target) return img, target def __len__(self) -> int: return len(self.images)以上实现，继承了 VisionDataset 子类。其 __getitem__ 返回了： ...

摘要：NanoDet 是一个速度超快和轻量级的挪动端 Anchor-free 指标检测模型。前言YOLO、SSD、Fast R-CNN等模型在指标检测方面速度较快和精度较高，然而这些模型比拟大，不太适宜移植到挪动端或嵌入式设施；轻量级模型 NanoDet-m，对单阶段检测模型三大模块（Head、Neck、Backbone）进行轻量化，指标加检测速度很快；模型文件大小仅几兆（小于4M）。 NanoDet作者开源代码地址：https://github.com/RangiLyu/nanodet （致敬） 基于NanoDet我的项目进行小裁剪，专门用来实现Python语言、PyTorch 版本的代码地址：https://github.com/guo-pu/NanoDet-PyTorch 下载间接能应用，反对图片、视频文件、摄像头实时指标检测 先看一下NanoDet指标检测的成果： 同时检测多辆汽车： 查看多指标、指标之间重叠、同时存在小指标和大指标的检测成果： NanoDet 模型介绍NanoDet是一种 FCOS 式的单阶段 anchor-free 指标检测模型，它应用 ATSS 进行指标采样，应用 Generalized Focal Loss 损失函数执行分类和边框回归（box regression）。 1）NanoDet 模型性能 NanoDet-m模型和YoloV3-Tiny、YoloV4-Tiny作比照： 备注：以上性能基于 ncnn 和麒麟 980 (4xA76+4xA55) ARM CPU 取得的。应用 COCO mAP (0.5:0.95) 作为评估指标，兼顾检测和定位的精度，在 COCO val 5000 张图片上测试，并且没有应用 Testing-Time-Augmentation。 NanoDet作者将 ncnn 部署到手机（基于 ARM 架构的 CPU 麒麟 980，4 个 A76 外围和 4 个 A55 外围）上之后跑了一下 benchmark，模型前向计算工夫只有 10 毫秒左右，而 yolov3 和 v4 tiny 均在 30 毫秒的量级。在安卓摄像头 demo app 上，算上图片预处理、检测框后处理以及绘制检测框的工夫，NanoDet也能轻松跑到 40+FPS。 ...

编译 | CV君报道 | 我爱计算机视觉（微信id：aicvml） YolactEdge 是第一个可在小型边缘设施上以实时速度运行的有竞争力的实例宰割办法。 在550x550分辨率的图像上，以ResNet-101为主干网的YolactEdge 在Jetson AGX Xavier上的运行速度高达30.8 FPS（在RTX 2080 Ti上的运行速度为172.7 FPS）。 YolactEdge: Real-time Instance Segmentation on the Edge (Jetson AGX Xavier: 30 FPS, RTX 2080 Ti: 170 FPS) 论文：https://arxiv.org/abs/2012.12259 代码：https://github.com/haotian-li...\_edge 单位：亚马逊；加利福尼亚大学戴维斯分校 作者：Haotian Liu, Rafael A. Rivera Soto, Fanyi Xiao, Yong Jae Lee 该文次要在YOLACT算法根底上进行了两个方面的改良： (1) TensorRT 程序优化，衡量速度和精度；  (2) 提出一种新的特色 warping 模块，以利用视频中的工夫冗余。 作者曾经提供了YouTube VIS 、COCO数据集上训练的泛滥模型： 能够间接跑起来。 对于做钻研的同学来说，作者也提供了简略不便的在支流数据集上评估办法，不便改良后模型比拟。 另外，该代码提供了具体的在已有和新数据集上的训练方法，不便做工程的同学本人训练。 相干演示Demo:https://www.bilibili.com/vide... 总之，对于做实例宰割的同学来说，YolactEdge是近期十分值得参考的算法。

背景源码克隆于https://github.com/ultralytic...，刚克隆下来训练本人的数据集有点无从下手，看其github源码主页提供的教程也是摸不着头脑，钻研了两天搞定，记录一下，心愿能够帮忙到和我雷同状况的小伙伴，感觉有用的话能够点赞珍藏一下，有谬误评论区斧正！另外介绍下我是mac作为本地电脑，在有4块gpu的服务器上近程训练的。 1. 克隆yolov3源码，筹备本人数据集，筹备预训练权重文件这里应用voc数据集，记得解压到你想放的地位 wget -c http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar预训练权重文件下载 wget -c https://pjreddie.com/media/files/darknet53.conv.74我是间接把它解压至我的项目根目录下的，你们能够本人决定门路，然而前面会有些代码局部须要相应批改对应此门路。我略微解释一下这个VOC2012上面几个文件夹，最初两个不必管，其实用不到，labels文件夹和lables.npy文件是我前面跑脚本生成的，你解压的是没有的，临时不论，Annotaions文件夹是寄存对应图片的xml文件，该文件是用标签语言来对图片的阐明，ImageSets里只关系Main这个文件夹，能够先把外面的文件删了，因为前面是要生成本人的txt文件的，外面记录的是对应训练集、验证集、测试集、训练验证集的图片名称。 2. 新增一个脚本 从数据集中随机生成训练集、验证集、测试集、训练验证集，并生成对应的txt文件，存到Voc2012/Imagesets/Main中，如图： get_train_val_txt.py(脚本代码如下，自行拷贝，并适当批改) import osimport random random.seed(0)xmlfilepath=r'./VOC2012/Annotations' # 改成你本人的Annotations门路saveBasePath=r"./VOC2012/ImageSets/Main/" # 改成你本人的ImageSets/Main门路 # 值能够本人取，决定你各个数据集的占比数trainval_percent=.8 train_percent=.7temp_xml = os.listdir(xmlfilepath)total_xml = []for xml in temp_xml: if xml.endswith(".xml"): total_xml.append(xml)num=len(total_xml) list=range(num) tv=int(num*trainval_percent) tr=int(tv*train_percent) trainval= random.sample(list,tv) train=random.sample(trainval,tr) ftrainval = open(os.path.join(saveBasePath,'trainval.txt'), 'w') ftest = open(os.path.join(saveBasePath,'test.txt'), 'w') ftrain = open(os.path.join(saveBasePath,'train.txt'), 'w') fval = open(os.path.join(saveBasePath,'val.txt'), 'w') for i in list: name=total_xml[i][:-4]+'\n' if i in trainval: ftrainval.write(name) if i in train: ftrain.write(name) else: fval.write(name) else: ftest.write(name) ftrainval.close() ftrain.close() fval.close() ftest .close() 3. 在data文件夹里新建两个文件 新建voc2012.data文件，外面配置如下 ...

大规模服务PyTorch Lightning模型的残缺指南。 纵观机器学习畛域，次要趋势之一是专一于将软件工程原理利用于机器学习的我的项目激增。 例如，Cortex再现了部署无服务器性能但具备推理管道的体验。相似地，DVC实现了古代版本控制和CI / CD管道，但仅用于ML。 PyTorch Lightning具备相似的理念，仅实用于训练。框架为PyTorch提供了Python包装器，可让数据科学家和工程师编写洁净，可治理且性能卓越的训练代码。 作为构建 整个部署平台的人 ，局部起因是咱们厌恶编写样板，因而咱们是PyTorch Lightning的忠诚拥护者。本着这种精力，我整顿了将PyTorch Lightning模型部署到生产环境的指南。在此过程中，咱们将钻研几种导出PyTorch Lightning模型以包含在推理管道中的选项。 部署PyTorch Lightning模型进行推理的每种办法有三种办法能够导出PyTorch Lightning模型进行投放： 将模型另存为PyTorch检查点将模型转换为ONNX将模型导出到Torchscript咱们能够通过Cortex为这三个服务。 1.间接打包和部署PyTorch Lightning模块从最简略的办法开始，让咱们部署一个没有任何转换步骤的PyTorch Lightning模型。 PyTorch Lightning Trainer是一个形象样板训练代码（思考训练和验证步骤）的类，它具备内置的save_checkpoint（）函数，该函数会将您的模型另存为.ckpt文件。要将模型保留为检查点，只需将以下代码增加到训练脚本中： 当初，在咱们开始为该检查点提供服务之前，须要留神的是，尽管我始终说“ PyTorch Lightning模型”，但PyTorch Lightning是PyTorch的包装器-我的项目的README字面意思是“ PyTorch Lightning只是有组织的PyTorch。” 因而，导出的模型是一般的PyTorch模型，能够相应地应用。 有了保留的检查点，咱们能够在Cortex中轻松地为模型提供服务。如果您不相熟Cortex，能够 在这里疾速相熟一下，然而Cortex部署过程的简略概述是： 咱们应用Python为咱们的模型编写了一个预测API咱们在YAML中定义咱们的API根底构造和行为咱们应用CLI中的命令部署API咱们的预测API将应用Cortex的Python Predictor类定义一个init（）函数来初始化咱们的API并加载模型，并应用一个define（）函数在查问时提供预测： 很简略 咱们从训练代码中从新调整了一些代码的用处，增加了一些推理逻辑，仅此而已。须要留神的一件事是，如果将模型上传到S3（举荐），则须要增加一些逻辑来拜访它。 接下来，咱们在YAML中配置基础架构： 再次，简略。咱们给咱们的API起个名字，通知Cortex咱们的预测API在哪里，并调配一些CPU。 接下来，咱们部署它： 请留神，咱们还能够部署到集群，由Cortex减速和治理： 在所有部署中，Cortex都会容器化咱们的API并将其公开为Web服务。通过云部署，Cortex能够配置负载平衡，主动扩大，监督，更新和许多其余基础架构性能。 就是这样！当初，咱们有一个实时Web API，可依据要求提供模型预测。 2.导出到ONNX并通过ONNX运行时进行投放当初，咱们曾经部署了一个一般的PyTorch检查点，让事件简单一些。 PyTorch Lightning最近增加了一个不便的形象，用于将模型导出到ONNX（以前，您能够应用PyTorch的内置转换性能，只管它们须要更多样板）。要将模型导出到ONNX，只需将以下代码增加到您的训练脚本中： 请留神，您的输出样本应模拟理论模型输出的形态。 导出ONNX模型后，就能够应用Cortex的ONNX Predictor为其提供服务。代码基本上看起来是雷同的，并且过程是雷同的。例如，这是一个ONNX预测API： 基本上一样。惟一的区别是，咱们不是通过间接初始化模型，而是通过onnx_client拜访该数据，这是Cortex为服务于咱们的模型而启动的ONNX运行时容器。 咱们的YAML看起来也很类似： 我在此处增加了一个监督标记，目标只是为了显示配置的简便水平，并且有一些ONNX特定字段，但其余方面都是雷同的YAML。 最初，咱们应用与之前雷同的$ cortex deploy命令进行部署，并且咱们的ONNX API已启用。 3.应用Torchscript的JIT编译器进行序列化对于最终部署，咱们将把PyTorch Lightning模型导出到Torchscript并应用PyTorch的JIT编译器提供服务。要导出模型，只需将其增加到您的训练脚本中： 用于此目标的Python API与原始PyTorch示例简直雷同： ...

进行深度学习时您将须要的所有PyTorch性能。从试验/钻研的角度来看。 PyTorch 曾经成为当初创立神经网络的事实上的规范之一，我喜爱它的界面。然而，对于初学者来说，要取得它有些艰难。 我记得几年前通过一些宽泛的试验之后才抉择PyTorch。实话实说，我花了很多工夫才捡起来，但我很快乐我从Keras搬到 PyTorch。 凭借其高度可定制性和python语法， PyTorch能够与 别人一起工作，这是我的荣幸，我将其举荐给任何心愿通过深度学习进行沉重工作的人。 因而，在本PyTorch指南中， 我将尝试加重PyTorch对于初学者的苦楚，并介绍在应用Pytorch 创立任何神经网络时须要的一些最重要的类和模块。 然而，这并不是说它仅针对初学者，因为 我还将议论 PyTorch提供的高可定制性，并议论自定义的Layers，Datasets，Dataloaders和Loss函数。 张量张量是PyTorch的根本构建块，简略地说，它们是NumPy数组，但在GPU上。在这一部分中，我将列出一些在应用Tensors时能够应用的最罕用的操作。这绝不是张量能够执行的详尽操作列表，然而在进行更令人兴奋的局部之前理解张量是有帮忙的。 1.创立张量咱们能够通过多种形式创立PyTorch张量。这包含从NumPy数组转换为张量。上面只是一个要点，上面是一些示例，然而您能够  像应用NumPy数组一样应用张量来做更多的事件。 2.张量运算同样，您能够对这些张量执行很多操作。 留神： 什么是PyTorch变量？在以前的Pytorch版本中，Tensor和Variables已经是不同的，并且提供了不同的性能，然而当初不赞成应用Variable API ，并且所有用于Tensors的变量 办法都能够应用。因而，如果您不理解它们，那很好，因为它们不是必须的，如果您理解它们，则能够将它们遗记。 nn.模块然而话又说回来，如果Pytorch没有提供很多现成的层，而这些层在各种神经网络体系结构中十分频繁地应用，则Pytorch不会被宽泛应用。一些例子是：nn.Linear，nn.Conv2d，nn.MaxPool2d，nn.ReLU，  nn.BatchNorm2d，nn.Dropout，nn.Embedding，  ，，  ，，，nn.GRU/nn.LSTMnn.Softmaxnn.LogSoftmaxnn.MultiheadAttentionnn.TransformerEncodernn.TransformerDecoder 在这里，咱们定义了一个非常简单的网络，该网络承受大小为784的输出，并以程序形式将其通过两个线性层。然而要留神的是，咱们能够在定义前向通过时定义任何类型的计算，这使得PyTorch高度可定制以用于钻研目标。例如，在疯狂的试验模式下，咱们可能应用了以下网络，在该网络上咱们任意附加了图层。在这里，咱们在将输出再次增加回第二个线性层（跳过连贯）之后，将输入从第二个线性层再次发送回第一个线性层。 咱们还能够查看神经网络正向传递是否起作用。通常，我首先创立一些随机输出，而后将其通过我创立的网络进行传递。 对于层的一句话Pytorch十分弱小，您实际上能够应用本人创立任何新的试验层 nn.Module。例如，而不是应用预约义的线性层 nn.Linear。从Pytorch以上，咱们能够曾经创立了 定制线性层。 您将看到如何在中包装权重张量。nn.Parameter.这样做是为了使张量被视为模型参数。 参数是 Tensor子类，当与Module-一起应用时具备十分非凡的属性 -当将它们调配为模块属性时，它们会主动增加到其参数列表中，并将呈现在 parameters()迭代器中。稍后您将看到，model.parameters()迭代器将成为优化器的输出。然而稍后会更多。当初，咱们当初能够在任何PyTorch网络中应用此自定义层，就像其余任何层一样。 然而话又说回来，如果Pytorch没有提供很多现成的层，而这些层在各种神经网络体系结构中十分频繁地应用，则Pytorch不会被宽泛应用。一些例子是：nn.Linear，nn.Conv2d，nn.MaxPool2d，nn.ReLU，  nn.BatchNorm2d，nn.Dropout，nn.Embedding，nn.GRU/nn.LSTM，nn.Softmax，nn.LogSoftmax，nn.MultiheadAttention，nn.TransformerEncoder，nn.TransformerDecoder 以上就是Torch的根底操作，下一篇文章会为同学们解说卷积局部的操作。

原作者：Davide Testuggine、Ilya Mironov，均为 Facebook AI 利用钻研科学家原文链接：https://ai.facebook.com/blog/... Opacus是一个可能训练PyTorch模型的差分隐衷的库。它反对在客户端上以最小的代码改变进行训练，对训练性能影响不大，并容许客户端在线跟踪任何给定时刻的隐衷估算收入。这个代码版本是针对两个指标受众：ML从业者会发现这是一个温和的介绍，以训练一个具备微分隐衷的模型，因为它须要最小的代码变动。差分隐衷科学家会发现这很容易进行试验和修整，让他们专一于重要的事件。Opacus是一种新的高速库，用于应用差分隐衷（DP）训练PyTorch模型，该库比现有的最新办法更具可扩展性。差别隐衷是用于量化敏感数据匿名化的严格数学框架。它通常用于剖析中，并且对机器学习（ML）社区的趣味日益浓重。随着Opacus的公布，咱们心愿为钻研人员和工程师提供一条更轻松的路径，以在ML中采纳差别隐衷，并减速该畛域的DP钻研。 Opacus提供：速度：通过利用PyTorch中的Autograd挂钩，Opacus能够计算成批的每个样本的梯度，与依赖微批处理的现有DP库相比，可将数量级的速度提速。平安：Opacus应用 明码平安的伪随机数生成器对其安全性至关重要的代码。这在GPU上高速解决了整批参数。灵活性：多亏了PyTorch，工程师和钻研人员能够通过将咱们的代码与PyTorch代码和纯Python代码进行混合和匹配来疾速创立他们的想法的原型。生产力：Opacus随附教程，辅助性能，这些性能甚至能够在你开始培训之前就正告不兼容的图层以及主动重构机制。交互性：Opacus会跟踪你在任何给定工夫点破费了多少隐衷估算（DP中的外围数学概念），从而可能提前进行和实时监控。Opacus通过引入PrivacyEngine形象定义了一个轻量级的API，该形象既能够跟踪你的隐衷估算，也能够解决模型的突变。你无需间接调用它即可运行，因为它已连贯到规范PyTorch优化器。它在后盾运行，使应用Opacus进行培训就像在培训代码的结尾增加以下代码行一样容易： model = Net()optimizer = torch.optim.SGD(model.parameters(), lr=0.05)privacy_engine = PrivacyEngine( model, batch_size=32, sample_size=len(train_loader.dataset), alphas=range(2,32), noise_multiplier=1.3, max_grad_norm=1.0,)privacy_engine.attach(optimizer)That's it! Now it's business as usual训练后，生成的工件是规范的PyTorch模型，没有额定的步骤或部署公有模型的阻碍：如果你明天能够部署模型，则能够在应用DP对其进行了训练之后进行部署，而无需更改任何代码。 Opacus库还包含通过事后训练和微调的模型，针对大型模型的教程以及为隐衷钻研试验而设计的根底构造。 应用Opacus实现高速隐衷培训咱们与Opacus的指标是保留每个训练样本的隐衷，同时限度对最终模型准确性的影响。 Opacus通过批改规范的PyTorch优化器来做到这一点，以便在训练过程中施行（和测量）DP。 更具体地说，咱们的办法集中在差分公有随机梯度降落（DP-SGD）上。 该算法背地的核心思想是，咱们能够通过干涉模型用来更新权重的参数梯度（而不是间接获取数据）来爱护训练数据集的隐衷。通过在每次迭代中将噪声增加到梯度中，咱们能够避免模型记住其训练示例，同时仍可进行汇总学习。（无偏的）噪声天然会在训练过程中看到的许多批次中对消。 然而，减少噪声须要奥妙的均衡：过多的噪声会毁坏信号，而过少的噪声将无奈保障隐衷。为了确定适合的比例，咱们看一下梯度的范数。限度每个样本对梯度的奉献很重要，因为离群值比大多数样本具备更大的梯度。咱们须要确保这些异样值的私密性，尤其是因为它们极有可能被模型记住。为此，咱们在一个小批处理中计算每个样本的梯度。咱们别离裁剪梯度，将其累积回单个梯度张量，而后将噪声增加到总和中。 这种基于样本的计算是构建Opacus的最大阻碍之一。与PyTorch的典型操作相比，它更具挑战性，主动毕业计算整个批次的梯度张量，因为这对于所有其余ML用例都是有意义的，并且能够优化性能。为了克服这个问题，咱们应用了高效技术训练规范神经网络时取得所有所需的梯度向量。对于模型参数，咱们独自返回给定批次中每个示例的损失梯度，如下所示： 这是Opacus工作流程的图表，咱们在其中计算每个样本的梯度。 通过在运行各层时跟踪一些两头数量，咱们能够应用适宜内存的任何批次大小进行训练，从而使咱们的办法比其余软件包中应用的代替微批次办法快一个数量级。 隐衷爱护机器学习的重要性平安社区激励平安要害代码的开发人员应用大量通过认真审查和业余保护的库。通过容许应用程序开发人员专一于他们最理解的事件：构建杰出的产品，这种“不自行加密”的准则有助于最大水平地缩小攻击面。随着ML的利用和钻研一直减速，对于ML钻研人员而言，重要的是应用易于应用的工具来取得数学上严格的隐衷保障，而不会拖慢培训过程。 咱们心愿通过开发Opacus等PyTorch工具，使对此类隐衷爱护资源的拜访民主化。咱们正在应用PyTorch更快，更灵便的平台弥合平安社区和个别ML工程师之间的鸿沟。 修建社区在过来的几年中，隐衷爱护机器学习（PPML）社区失去了疾速倒退。咱们为Opacus四周曾经造成的生态系统感到兴奋，咱们的次要贡献者之一是OpenMined，这是一个由数千名开发人员组成的社区，他们正在构建以隐衷为核心的利用。并利用许多PyTorch构建块为PySyft和PyGrid提供根底，以实现差异化隐衷和联结学习。作为单干的一部分，Opacus将成为OpenMined库（例如PySyft）的依赖项。咱们期待持续咱们的单干，并进一步扩充社区。 Opacus是Facebook AI促成工作提高的更宽泛致力的一部分平安倒退 计算技术用于机器学习和负责任的人工智能。总体而言，这是未来将其畛域转向构建隐衷优先零碎的重要踏脚石。 为了更深刻地理解差别隐衷的概念，咱们将开设一系列专门针对差别公有机器学习的中级职位。第一局部着眼于要害的基本概念。在此处浏览PyTorch Medium博客。咱们还提供全面的教程和 Opacus开源库在这里。开源地址：https://github.com/pytorch/op...

随着AI行业的高速倒退，越来越多的人想要投身人工智能畛域，掀起学习Python的热潮，然而很多人在纠结本人是不是有必要加入培训学习，第一是感觉培训学习须要一笔费用，第二很多人是间接去网上理解培训学习，然而网上对培训的评估褒贬不一，看着网上那些，很多人在纠结到底需不需要加入培训学习。 那到底报Python培训班真的有必要吗?上面小编就从Python学习打算，学习效果，学习实际等多方面分析一下这个问题，给各位筹备学习的小伙伴一点倡议。 从学习打算来说 因为咱们对Python常识储备无限甚至是齐全不理解，在这个状况下，只能去购买Python培训相干书籍或者是从网上下载或者是去购买一些课程视频进行学习，随之而来的问题就是不晓得哪里是重点，对常识把握只知其一;不知其二，无奈齐全了解各个知识点之间的连贯。所以咱们还是须要多和有教训的前辈或老师进行交换，更加具体的理解到Python是须要具体怎么去学，这还是很有必要的。 遇到问题无奈解决 在咱们自学的过程中，未免会遇到咱们无奈了解或者是解决的问题，这个时候要怎么办呢?去各个业余群里问问大佬，或者是各个问答博客论坛去寻找答案。这样折腾一圈，要是问题解决了还好，然而要是没有解决，那不光浪费时间，还会影响到你接下来的学习进度，如果有业余的老师在旁边的话，你就不会存在问题当天无奈解决的问题啦。 从学习效果来说 自学的话，一些根底的货色靠了解记忆，然而波及到我的项目，就有点无从下手了，学习效果可能不尽如人意，最多也就是照葫芦画瓢，难以把握其精粹和吸取其中的教训。再来看报班培训，学习分阶段，我的项目波及到每个阶段，是常识的坚固，也是技能的降级。学习效果必定是事倍功半，而且每个我的项目都来源于一线企业，由讲师率领，一步步入手操作，最初失去的是整个我的项目下来满满的经验值，这个时候你会感觉加入培训真的很有必要! 没有方法实际 对于转行过去的新人来说，去学习基础知识是必要的，然而肯定要进行实际操作能力看出问题出在哪里。有时候你可能感觉看完了Python常识的书籍，对常识有了肯定的了解，然而还是写不进去货色，感觉无从下手，这就是短少练习和实际操作的体现。这种状况就相当于节约掉之前的学习工夫。 学习Python报一个培训班，能从基础知识到进阶课程，遇到问题能通过老师为你解说，让你从浅到深进行学习，并且通过实践与实际相结合的教学方式，让你能够更加粗浅的了解相干课程。所以报班的确有必要。

state_dict = torch.load(opts.checkpoint)try: trainer.net.load_state_dict(state_dict['net_param'])except Exception: trainer.net = torch.nn.DataParallel(trainer.net) trainer.net.load_state_dict(state_dict['net_param'])This is for dealing a checkpoint trained in parallel. try: out = trainer.net.forward()except: out = trainer.net.module.forward()Simialarly, the net need to be transformed to module for being compatible with paralelly trained model.

阐明：torch.cuda.is_available()这个指令的作用是看你电脑的 GPU 是否被 PyTorch 调用。如果返回的后果是 False，能够依照以下过程进行排查。 Step1：确认硬件反对，确认你的 GPU是否反对 CUDA（是否反对被 PyTorch 调用） 1.确定计算机中是否是独立显卡，是否是 NVIDIA 显卡。能够从 工作管理器 或者 设施管理器 来查看显卡的型号。 工作管理器->性能->GPU： 我的电脑->属性->设施管理器->显示适配器： 有“NVIDIA GeForce 840M”字样信息示意有独立显卡。 2.去 NVIDIA官网 查看其中是否有你的显卡型号，如果有，则阐明你的显卡是反对被 PyTorch 调用的。 Step2：查看显卡驱动版本并更新。 1.关上命令行，输出 nvidia-smi，查看本人的 “Driver Version” 注：如呈现如下报错： 'nvidia-smi' 不是外部或外部命令，也不是可运行的程序请参考文末“可能遇到的问题”进行解决。 一般而言，不同版本的CUDA要求不同的NVIDIA驱动版本,同时显卡驱动版本要不低于CUDA的装置版本。 CUDA对显卡驱动版本要求如图： 比方我装置的是 PyTorch 1.5 + CUDA 9.2 版本，要求电脑的显卡驱动大于398.26。 2.如果驱动版本太低，在官网，下载对应的最新驱动并装置更新。 抉择相应的显卡型号，操作系统，下载类型和语言默认。其中的 Notebooks 是指笔记本。 之后，点击搜寻，下载最新驱动后，依照指引进行装置即可。 Step3：验证驱动版本及GPU是否可调用。 1.再次在终端窗口输出 nvidia-smi，查看最新的版本是否装置胜利。 2.进入python环境： conda activate pytorchpython3.在python环境中： import torchtorch.cuda.is_available()查看返回后果是否是True 可能遇到的问题：1.执行'nvidia-smi' 命令时提醒'nvidia-smi'不是外部或外部命令，也不是可运行的程序 起因：因为它找不到该命令。这个文件是一个exe文件，个别都在上面这个文件夹中。 C:\Program Files\NVIDIA Corporation\NVSMI所以想要应用该命令必须要能失去这个文件夹，能力执行。 解决：增加环境变量 ...

本文首发于集体博客 http://zuyunfei.com/2020/07/1...，欢送浏览最新内容！ 最近拿到一块CORE-3399PRO-JD4开发板，要在下面部署AI利用。这块板子搭载Rockchip RK3399Pro处理器，采纳双核 Cortex-A72+四核 Cortex-A53构架，主频高达 1.8GHz，集成四核Mali-T864 GPU，并内置高性能NPU，号称性能优异。然而理论过程中，发现发热重大，要应用NPU须要把算法移植到Rockchip提供的RKNN-Toolkit开发套件。依照官网文档把板子刷成了ubuntu18.4，而后装置了RKNN，打算把现有模型转换一下，后果发现： 适配的tensorflow版本较低（RKNN 1.3 反对tensorflow 1.10.1），2.0版本的模型无奈转换。ONNX版本模型转换失败，应该也是版本不对pytorch罗唆没有迁徙到板子上，官网例程都跑不起来。切实没方法，只能先不必NPU把利用跑起来试试。这里把编译在ARM Ubuntu18.04上编译pytorch和opencv的过程记录一下。 编译pytorch在开发板上编译，须要先装置编译工具链（要联网）。因为开始编译前我曾经折腾这块板子好多天了，上面列出的依赖可能不是全副。 sudo apt-get install libopenblas-dev libblas-dev m4 cmake cython而后装置python依赖，我这里应用的是python3.6。 pip3 install numpy pyyaml cyphon从gitbub拿下来pytorch源码，submodule update 过程必不可少。 git clone --recursive https://github.com/pytorch/pytorchcd pytorchgit checkout v1.4git submodule syncgit submodule update --init --recursivegit submodule update --remote third_party/protobuf配置环境变量 export NO_CUDA=1 #不实用cudaexport NO_DISTRIBUTED=1 #不反对分布式export NO_MKLDNN=1 #不反对MKLDNNexport MAX_JOBS=4 须要留神的是MAX_JOBS是并行编译的最大线程数。（尽管CORE-3399PRO-JD4 这块板子是6核CPU，能够反对6线程编译，然而它只有4GB内存，编译一些简单模块时，GCC会耗尽内存解体。我的教训是先用4线程或6线程编译，遇到GCC解体，再改回单线程编译，耗内存的模块编译过之后再改回6线程编译。） 开始编译 #打包成whl，打包胜利后这个文件在dist目录外面python setup.py bdist_wheel装置编译好的wheel包 cd distpip3 install ./torch-1.4.0a0+72e1771-cp36-cp36m-linux_aarch64.whl编译torchvision先装置编译依赖 sudo apt-get install libjpeg-dev libavcodec-dev libavformat-dev libswscale-devpip3 install pillow从gitbub clone 代码 ...

0实践上带有一个非线性函数的网络可能拟合任意函数。那显然MLP和RNN是科研拟合sinx的。结尾先把后果给展现进去，而后是代码，最初是我的过程。懒得看的间接看前半部分行了，过程给有趣味的人看看。先上后果图注：每次训练torch初始化有不同，所以后果有出入。代码乍一看挺多的，实际上简略得一批。只不过是定义了两个网络，训练了两次，展现图片的反复代码而已。具体代码曾经正文。import torchimport mathimport matplotlib.pyplot as pltclass MLP(torch.nn.Module): def __init__(self): super().__init__() self.layer1=torch.nn.Linear(1,16) self.layer2=torch.nn.Linear(16,16) self.layer3=torch.nn.Linear(16,1) def forward(self,x): x=self.layer1(x) x=torch.nn.functional.relu(x) x=self.layer2(x) x=torch.nn.functional.relu(x) x=self.layer3(x) return x# rnn takes 3d input while mlp only takes 2d inputclass RecNN(torch.nn.Module): def __init__(self): super().__init__() self.rnn=torch.nn.LSTM(input_size=1,hidden_size=2,num_layers=1,batch_first=True) #至于这个线性层为什么是2维度接管，要看最初网络输入的维度是否匹配label的维度 self.linear=torch.nn.Linear(2,1) def forward(self,x): # print("x shape: {}".format(x.shape)) # x [batch_size, seq_len, input_size] output,hn=self.rnn(x) # print("output shape: {}".format(output.shape)) # out [seq_len, batch_size, hidden_size] x=output.reshape(-1,2) # print("after change shape: {}".format(x.shape)) x=self.linear(x) # print("after linear shape: {}".format(x.shape)) return xdef PlotCurve(mlp, rnn, input_x, x): # input_x 是输出网络的x。 # sin_x 是列表，x的取值，一维数据、 # 尽管他们的内容（不是维度）是一样的。能够print shape看一下。 mlp_eval = mlp.eval() rnn_eval = rnn.eval() mlp_y = mlp_eval(input_x) rnn_y = rnn_eval(input_x.unsqueeze(0)) plt.figure(figsize=(6, 8)) plt.subplot(211) plt.plot([i + 1 for i in range(EPOCH)], mlp_loss, label='MLP') plt.plot([i + 1 for i in range(EPOCH)], rnn_loss, label='RNN') plt.title('loss') plt.legend() plt.subplot(212) plt.plot(x, torch.sin(x), label="original", linewidth=3) plt.plot(x, [y[0] for y in mlp_y], label='MLP') plt.plot(x, [y[0] for y in rnn_y], label='RNN') plt.title('evaluation') plt.legend() plt.tight_layout() plt.show()#常量都取出来，以便改变EPOCH=1000RNN_LR=0.01MLP_LR=0.001left,right=-10,10PI=math.piif __name__ == '__main__': mlp=MLP() rnn=RecNN() # x,y 是一般sinx 的torch tensor x = torch.tensor([num * PI 4 for num in range(left, right)]) y = torch.sin(x) # input_x和labels是训练网络时候用的输出和标签。 input_x=x.reshape(-1, 1) labels=y.reshape(-1,1) #训练mlp mlp_optimizer=torch.optim.Adam(mlp.parameters(), lr=MLP_LR) mlp_loss=[] for epoch in range(EPOCH): preds=mlp(input_x) loss=torch.nn.functional.mse_loss(preds,labels) mlp_optimizer.zero_grad() loss.backward() mlp_optimizer.step() mlp_loss.append(loss.item()) #训练rnn rnn_optimizer=torch.optim.Adam(rnn.parameters(),lr=RNN_LR) rnn_loss=[] for epoch in range(EPOCH): preds=rnn(input_x.unsqueeze(0)) # print(x.unsqueeze(0).shape) # print(preds.shape) # print(labels.shape) loss=torch.nn.functional.mse_loss(preds,labels) rnn_optimizer.zero_grad() loss.backward() rnn_optimizer.step() rnn_loss.append(loss.item()) PlotCurve(mlp, rnn, input_x, x)一些留神的点（过程）有些人的代码是多加了dalaloader来做了数据集的loader，我集体认为没啥必要，这么简略的货色。当然加了loader或者更加合乎习惯。为什么数据只取了20个（从left到right只有sinx的20个数据）？我一开始是从-128左近取到了128左近，然而发现训练成果奇差无比，狐疑人生了都。这仅仅取了20个数据，都须要1000次训练，更大的数据集的工夫代价可见一斑。RNN的lr是0.01，MLP的是0.001？这个也是依据loss的图来调节的，0.001在我这个rnn里并不适宜，训练太慢了。而且为了和mlp的EPOCH保持一致，就换了0.01的学习率。然而为什么RNN比MLP降落的慢？这个有待进一步探讨（当然是因为我太菜了）。对于loss function，为什么用mse loss？轻易选的。我又换了l1_loss和其余的loss试了，成果差不多，毕竟这么简略的函数拟合，什么损失函数无所谓了。论文指出，RNN系列网络比MLP拟合工夫序列数据能力更强，为什么这次训练反而比MLP降落更慢？不仅如此，其实如果屡次比拟MLP和RNN的拟合成果，发现MLP成果更稳固更好一些，这又是为什么呢？有待进一步探讨。 ...

研一下学期和组内同学一同参加了KDD Autograph2020的比赛，最后也拿到了第二名的成绩，下面对本次比赛做个总结。 PASA_NJU代码总结github代码 使用GraphNas对数据集搜索网络模型。(引自 Gao Y, Yang H, Zhang P, et al. Graphnas: Graph neural architecture search with reinforcement learning[J]. arXiv preprint arXiv:1904.09981, 2019.)使用决策树根据数据集元信息，如节点数、边数、平均度等进行模型选择。特征工程，我们发现将lpa和对特征的预测概率分布加入到features中对于citation类型图数据集会有性能提升，将边关系矩阵作为特征对于一些图数据集也会有提升。加入EarlyStop早停机制以及自适应的集成策略。JunweiSun代码总结github代码 根据标签类别比率平衡loss（平衡的权重是比率开根号的倒数），类别数小于10或最大类别数小于最小类别数*10不使用。使用microsoft的automl工具nni搜索模型超参，训练过程搜参，搜索空间较小。使用0.1比例的验证集，评估指标为F1-score，验证集分值使用指数移动加权平均值来计算。复现了多个论文的模型，如ResGCN, GraphSAGE, GIN, ARMA等，模型选择根据图信息如特征维度，平均度，是否为有向图选择。特征工程，实现了one_hot / svd / degree / node2vec / adj等特征，实际上在原来特征上添加了svd特征。

简介 每过一段时间，就会有一个深度学习库被开发，这些深度学习库往往可以改变深度学习领域的景观。Pytorch就是这样一个库。 在过去的一段时间里，我研究了Pytorch，我惊叹于它的操作简易。Pytorch是我迄今为止所使用的深度学习库中最灵活的，最轻松的。 在本文中，我们将以实践的方式来探索Pytorch，包括基础知识与案例研究。我们会使用numpy和Pytorch分别从头开始构建神经网络，看看他们的相似之处。 提示：本文假设你已经对深度学习有一定的了解。如果你想深入学习深度学习，请先阅读本文。 内容目录 Pytorch概述深层技术在Numpy和Pytorch中构建神经网络与其他深度学习库的比较案例研究——使用Pytorch解决图像识别问题Pytorch概述 Pytorch的创作者说他们有一种理念——他们希望工具能够即时运作，这也就以为这我们必须及时进行运算。这也非常适用于python的编程方式，因为我们不必去等到程序都编完而确定整个代码是否有效。我们可以轻松得运行部分代码并且可以实时检查。这个神经网络的软件，对我来说是非常好用的。 PyTorch是一个基于python的库，旨在提供灵活性作为深度学习开发平台。PyTorch的工作流程也尽可能接近python的科学计算库——numpy。 现在你可能会问，为什么我们会使用PyTorch来构建深度学习模型？我可以列出三个可能有助于回答这个问题的事情： 易于使用API——它就像python一样简单。支持Python——就像上面所介绍的，Pytorch与python数据科学堆栈平滑集成。它跟numpy非常相似，你可能都没有注意到它们的区别。动态计算图形——Pytorch不是使用特定功能的预定义图形，而是为我们提供了构建计算图形的框架，甚至可以在运行的时候更改它们。这对于我们不知道创建神经网络需要多少内存的情况非常有用。使用Pytorch还有一些其他的优点，例如它的multiGPU支持，自定义数据加载器和简化的预处理器。 自2016年1月初发布以来，许多研究人员将其作为首选库，因为它易于构建新颖甚至极其复杂的图形。话虽如此，因为它比较新并且正在发展中，PyTorch仍然需要一段时间才能被大多数数据科学从业者采用。 深层技术 在深入了解工作细节之前，让我们来看看Pytorch的工作流程。 Pytorch构建图形所需的每行代码都定义了该图形的一个组件。即使在完全构建图形之前，我们也可以独立地对这些组件进行计算。这叫做“按运行定义”的方法。 安装PyTorch非常简单。您可以按照官方文档中提到的步骤操作，并根据您的系统规范运行命令。例如，这是我根据我选择的选项使用的命令： conda install pytorch torchvision cuda91 -c pytorch 开始使用Pytorch时我们应该知道的主要元素是： Pytorch 张量数学运算Autograd 模块Optim 模块nn 模块下面，我们具体看看每块元素是什么情况。 Pytorch 张量 张量只不多是多维数组。Pytorch中的张量类似于numpy的ndarray，另外张量也可以在GPU上使用。Pytorch支持各种类型的张量。 你可以定义一个简单的一位矩阵，如下所示： import pytorch import torch # define a tensor torch.FloatTensor([2])2 [torch.FloatTensor of size 1] 数学运算 与numpy一样，科学计算库能够有效得实现数学函数是非常有效的。Pytorch为你提供了类似的交互界面，你可以在这里使用200多个数学运算。 下面是Pytorch中的一个简单加法操作的例子： a = torch.FloatTensor([2]) b = torch.FloatTensor([3]) a + b 5 [torch.FloatTensor of size 1] 这是python中的一个重要部分。我们还可以在我们定义的Pytorch张量上执行各种矩阵运算。例如：我们来转置二维矩阵： ...

参与方式：https://github.com/apachecn/p... 整体进度：https://github.com/apachecn/p... 项目仓库：https://github.com/apachecn/p... 整体进度章节贡献者进度校验者进度教程部分----Deep Learning with PyTorch: A 60 Minute Blitz@bat67100%@AllenZYJ What is PyTorch?@bat67100%@AllenZYJ Autograd: Automatic Differentiation@bat67100%@AllenZYJ Neural Networks@bat67100%@AllenZYJ Training a Classifier@bat67100%@AllenZYJ Optional: Data Parallelism@bat67100% Data Loading and Processing Tutorial@yportne13100% Learning PyTorch with Examples@bat67100%@Smilexuhc Transfer Learning Tutorial@jiangzhonglian100%@infdahai Deploying a Seq2Seq Model with the Hybrid Frontend@cangyunye100% Saving and Loading Models@bruce1408100% What is torch.nn really?@lhc741100% Finetuning Torchvision Models@ZHHAYO100% Spatial Transformer Networks Tutorial@PEGASUS1993100%@Smilexuhc Neural Transfer Using PyTorch@bdqfork100% Adversarial Example Generation@cangyunye100%@infdahai Transfering a Model from PyTorch to Caffe2 and Mobile using ONNX@PEGASUS1993100% Chatbot Tutorial@a625687551100% Generating Names with a Character-Level RNN@hhxx2015100% Classifying Names with a Character-Level RNN@hhxx2015100% Deep Learning for NLP with Pytorch@bruce1408100% Introduction to PyTorch@guobaoyo100% Deep Learning with PyTorch@bdqfork100% Word Embeddings: Encoding Lexical Semantics@sight007100%@Smilexuhc Sequence Models and Long-Short Term Memory Networks@ETCartman100% Advanced: Making Dynamic Decisions and the Bi-LSTM CRF@JohnJiangLA Translation with a Sequence to Sequence Network and Attention@mengfu188100% DCGAN Tutorial@wangshuai9517100% Reinforcement Learning (DQN) Tutorial@friedhelm739100% Creating Extensions Using numpy and scipy@cangyunye100% Custom C++ and CUDA Extensions@P3n9W31 Extending TorchScript with Custom C++ Operators@sunxia233 Writing Distributed Applications with PyTorch@firdameng100% PyTorch 1.0 Distributed Trainer with Amazon AWS@yportne13100% ONNX Live Tutorial@PEGASUS1993100% Loading a PyTorch Model in C++@talengu100% Using the PyTorch C++ Frontend@solerji100% 文档部分----Autograd mechanics@PEGASUS1993100% Broadcasting semantics@PEGASUS1993100% CUDA semantics@jiangzhonglian100% Extending PyTorch@PEGASUS1993100% Frequently Asked Questions@PEGASUS1993100% Multiprocessing best practices@cvley100% Reproducibility@WyattHuang1 Serialization semantics@yuange250100% Windows FAQ@PEGASUS1993100% torch@yiran7324 torch.Tensor@hijkzzz100% Tensor Attributes@yuange250100% Type Info@PEGASUS1993100% torch.sparse@hijkzzz100% torch.cuda@bdqfork100% torch.Storage@yuange250100% torch.nn@yuange250100% torch.nn.functional@hijkzzz100% torch.nn.init@GeneZC100% torch.optim@qiaokuoyuan Automatic differentiation package - torch.autograd@gfjiangly100% Distributed communication package - torch.distributed@univeryinli100% Probability distributions - torch.distributions@hijkzzz100% Torch Script@keyianpai100% Multiprocessing package - torch.multiprocessing@hijkzzz100% torch.utils.bottleneck@belonHan100% torch.utils.checkpoint@belonHan100% torch.utils.cpp_extension@belonHan100% torch.utils.data@BXuan694100% torch.utils.dlpack@kunwuz100% torch.hub@kunwuz100% torch.utils.model_zoo@BXuan694100% torch.onnx@guobaoyo100% Distributed communication package (deprecated) - torch.distributed.deprecated@luxinfeng torchvision Reference@BXuan694100% torchvision.datasets@BXuan694100% torchvision.models@BXuan694100% torchvision.transforms@BXuan694100% torchvision.utils@BXuan694100% 奖励贡献者可以领取官方的纪念礼物。邮件部分内容如下： ...

【主页】 apachecn.org【Github】@ApacheCN暂时下线: 社区暂时下线: cwiki 知识库自媒体平台微博：@ApacheCN知乎：@ApacheCNCSDN | 简书 | OSChina | 博客园头条号 | 搜狐号 | bilibili 专栏We are ApacheCN Open Source Organization, not ASF! We are fans of AI, and have no relationship with ASF!合作or侵权，请联系【fonttian】<fonttian@gmail.com> | 请抄送一份到 <apachecn@163.com>seaborn 0.9 中文文档参与方式：https://github.com/apachecn/s…整体进度：https://github.com/apachecn/s…项目仓库：https://github.com/apachecn/s…认领：6/74，翻译：2/74序号章节译者进度1An introduction to seaborn@yiran7324 2Installing and getting started@neolei100%3Visualizing statistical relationships@JNJYan100%4Plotting with categorical data@hold2010 5Visualizing the distribution of a dataset@alohahahaha 6Visualizing linear relationships 7Building structured multi-plot grids@keyianpai 8Controlling figure aesthetics 9Choosing color palettes 10seaborn.relplot 11seaborn.scatterplot 12seaborn.lineplot 13seaborn.catplot 14seaborn.stripplot 15seaborn.swarmplot 16seaborn.boxplot 17seaborn.violinplot 18seaborn.boxenplot 19seaborn.pointplot 20seaborn.barplot 21seaborn.countplot 22seaborn.jointplot 23seaborn.pairplot 24seaborn.distplot 25seaborn.kdeplot 26seaborn.rugplot 27seaborn.lmplot 28seaborn.regplot 29seaborn.residplot 30seaborn.heatmap 31seaborn.clustermap 32seaborn.FacetGrid 33seaborn.FacetGrid.map 34seaborn.FacetGrid.map_dataframe 35seaborn.PairGrid 36seaborn.PairGrid.map 37seaborn.PairGrid.map_diag 38seaborn.PairGrid.map_offdiag 39seaborn.PairGrid.map_lower 40seaborn.PairGrid.map_upper 41seaborn.JointGrid 42seaborn.JointGrid.plot 43seaborn.JointGrid.plot_joint 44seaborn.JointGrid.plot_marginals 45seaborn.set 46seaborn.axes_style 47seaborn.set_style 48seaborn.plotting_context 49seaborn.set_context 50seaborn.set_color_codes 51seaborn.reset_defaults 52seaborn.reset_orig 53seaborn.set_palette 54seaborn.color_palette 55seaborn.husl_palette 56seaborn.hls_palette 57seaborn.cubehelix_palette 58seaborn.dark_palette 59seaborn.light_palette 60seaborn.diverging_palette 61seaborn.blend_palette 62seaborn.xkcd_palette 63seaborn.crayon_palette 64seaborn.mpl_palette 65seaborn.choose_colorbrewer_palette 66seaborn.choose_cubehelix_palette 67seaborn.choose_light_palette 68seaborn.choose_dark_palette 69seaborn.choose_diverging_palette 70seaborn.load_dataset 71seaborn.despine 72seaborn.desaturate 73seaborn.saturate 74seaborn.set_hls_values HBase 3.0 中文参考指南参与方式：https://github.com/apachecn/h…整体进度：https://github.com/apachecn/h…项目仓库：https://github.com/apachecn/h…认领：18/31，翻译：11/31章节译者进度Preface@xixici100%Getting Started@xixici100%Apache HBase Configuration@xixici100%Upgrading@xixici100%The Apache HBase Shell@xixici100%Data Model@Winchester-Yi HBase and Schema Design@RaymondCode100%RegionServer Sizing Rules of Thumb HBase and MapReduce@BridgetLai100%Securing Apache HBase Architecture@RaymondCode In-memory Compaction@mychaow Backup and Restore@mychaow Synchronous Replication@mychaow Apache HBase APIs@xixici100%Apache HBase External APIs@xixici100%Thrift API and Filter Language@xixici100%HBase and Spark@TsingJyujing100%Apache HBase Coprocessors@TsingJyujing Apache HBase Performance Tuning Troubleshooting and Debugging Apache HBase Apache HBase Case Studies Apache HBase Operational Management Building and Developing Apache HBase Unit Testing HBase Applications Protobuf in HBase@TsingJyujing Procedure Framework (Pv2): HBASE-12439 AMv2 Description for Devs ZooKeeper Community Appendix PyTorch 1.0 中文文档参与方式：https://github.com/apachecn/p…整体进度：https://github.com/apachecn/p…项目仓库：https://github.com/apachecn/p…教程部分：认领：37/37，翻译：34/37；文档部分：认领：37/39，翻译：34/39章节贡献者进度教程部分–Deep Learning with PyTorch: A 60 Minute Blitz@bat67100%What is PyTorch?@bat67100%Autograd: Automatic Differentiation@bat67100%Neural Networks@bat67100%Training a Classifier@bat67100%Optional: Data Parallelism@bat67100%Data Loading and Processing Tutorial@yportne13100%Learning PyTorch with Examples@bat67100%Transfer Learning Tutorial@jiangzhonglian100%Deploying a Seq2Seq Model with the Hybrid Frontend@cangyunye100%Saving and Loading Models@bruce1408100%What is torch.nn really?@lhc741100%Finetuning Torchvision Models@ZHHAYO100%Spatial Transformer Networks Tutorial@PEGASUS1993100%Neural Transfer Using PyTorch@bdqfork100%Adversarial Example Generation@cangyunye100%Transfering a Model from PyTorch to Caffe2 and Mobile using ONNX@PEGASUS1993100%Chatbot Tutorial@a625687551100%Generating Names with a Character-Level RNN@hhxx2015100%Classifying Names with a Character-Level RNN@hhxx2015100%Deep Learning for NLP with Pytorch@bruce1408100%Introduction to PyTorch@guobaoyo100%Deep Learning with PyTorch@bdqfork100%Word Embeddings: Encoding Lexical Semantics@sight007100%Sequence Models and Long-Short Term Memory Networks@ETCartman100%Advanced: Making Dynamic Decisions and the Bi-LSTM CRF@JohnJiangLA Translation with a Sequence to Sequence Network and Attention@mengfu188100%DCGAN Tutorial@wangshuai9517100%Reinforcement Learning (DQN) Tutorial@friedhelm739100%Creating Extensions Using numpy and scipy@cangyunye100%Custom C++ and CUDA Extensions@Lotayou Extending TorchScript with Custom C++ Operators@cloudyyyyy Writing Distributed Applications with PyTorch@firdameng100%PyTorch 1.0 Distributed Trainer with Amazon AWS@yportne13100%ONNX Live Tutorial@PEGASUS1993100%Loading a PyTorch Model in C++@talengu100%Using the PyTorch C++ Frontend@solerji100%文档部分–Autograd mechanics@PEGASUS1993100%Broadcasting semantics@PEGASUS1993100%CUDA semantics@jiangzhonglian100%Extending PyTorch@PEGASUS1993100%Frequently Asked Questions@PEGASUS1993100%Multiprocessing best practices@cvley100%Reproducibility@WyattHuang1 Serialization semantics@yuange250100%Windows FAQ@PEGASUS1993100%torch torch.Tensor@hijkzzz100%Tensor Attributes@yuange250100%Type Info@PEGASUS1993100%torch.sparse@hijkzzz100%torch.cuda@bdqfork100%torch.Storage@yuange250100%torch.nn@yuange250 torch.nn.functional@hijkzzz100%torch.nn.init@GeneZC100%torch.optim@qiaokuoyuan Automatic differentiation package - torch.autograd@gfjiangly100%Distributed communication package - torch.distributed@univeryinli100%Probability distributions - torch.distributions@hijkzzz100%Torch Script@keyianpai100%Multiprocessing package - torch.multiprocessing@hijkzzz100%torch.utils.bottleneck@belonHan100%torch.utils.checkpoint@belonHan100%torch.utils.cpp_extension@belonHan100%torch.utils.data@BXuan694100%torch.utils.dlpack@kunwuz100%torch.hub@kunwuz100%torch.utils.model_zoo@BXuan694100%torch.onnx@guobaoyo100%Distributed communication package (deprecated) - torch.distributed.deprecated torchvision Reference@BXuan694100%torchvision.datasets@BXuan694100%torchvision.models@BXuan694100%torchvision.transforms@BXuan694100%torchvision.utils@BXuan694100%AirFlow 中文文档参与方式：https://github.com/apachecn/a…整体进度：https://github.com/apachecn/a…项目仓库：https://github.com/apachecn/a…认领：25/30，翻译：24/30章节贡献者进度1 项目@zhongjiajie100%2 协议-100%3 快速开始@ImPerat0R_100%4 安装@Thinking Chen100%5 教程@ImPerat0R_100%6 操作指南@ImPerat0R_100%7 设置配置选项@ImPerat0R_100%8 初始化数据库后端@ImPerat0R_100%9 使用操作器@ImPerat0R_100%10 管理连接@ImPerat0R_100%11 保护连接@ImPerat0R_100%12 写日志@ImPerat0R_100%13 使用Celery扩大规模@ImPerat0R_100%14 使用Dask扩展@ImPerat0R_100%15 使用Mesos扩展（社区贡献）@ImPerat0R_100%16 使用systemd运行Airflow@ImPerat0R_100%17 使用upstart运行Airflow@ImPerat0R_100%18 使用测试模式配置@ImPerat0R_100%19 UI /截图@ImPerat0R_100%20 概念@ImPerat0R_100%21 数据分析@ImPerat0R_100%22 命令行接口@ImPerat0R_100%23 调度和触发器@Ray100%24 插件@ImPerat0R_100%25 安全 26 时区 27 实验性 Rest API@ImPerat0R_100%28 集成 29 Lineage 30 常见问题@zhongjiajie 31 API 参考 UCB CS61b：Java 中的数据结构参与方式：https://github.com/apachecn/c…整体进度：https://github.com/apachecn/c…项目仓库：https://github.com/apachecn/c…认领：5/12，翻译：1/12标题译者进度一、算法复杂度@leader402二、抽象数据类型@Allenyep100%三、满足规范 四、序列和它们的实现@biubiubiuboomboomboom五、树@biubiubiuboomboomboom六、搜索树 七、哈希 八、排序和选择@Rachel-Hu九、平衡搜索 十、并发和同步 十一、伪随机序列 十二、图 UCB Prob140：面向数据科学的概率论参与方式：https://github.com/apachecn/p…整体进度：https://github.com/apachecn/p…项目仓库：https://github.com/apachecn/p…认领：21/25，翻译：19/25标题译者翻译进度一、基础飞龙100%二、计算几率飞龙100%三、随机变量飞龙100%四、事件之间的关系@biubiubiuboomboomboom100%五、事件集合 >0%六、随机计数@viviwong100%七、泊松化@YAOYI626100%八、期望 50%九、条件（续）@YAOYI626100%十、马尔科夫链喵十八100%十一、马尔科夫链（续）喵十八100%十二、标准差缺只萨摩 100%十三、方差和协方差缺只萨摩 100%十四、中心极限定理喵十八100%十五、连续分布@ThunderboltSmile十六、变换十七、联合密度@Winchester-Yi100%十八、正态和 Gamma 族@Winchester-Yi100%十九、和的分布平淡的天100%二十、估计方法平淡的天100%二十一、Beta 和二项@lvzhetx100%二十二、预测 50%二十三、联合正态随机变量@JUNE951234二十四、简单线性回归@ThomasCai100%二十五、多元回归@lanhaixuan100%OpenCV 4.0 中文文档参与方式：https://github.com/apachecn/o…整体进度：https://github.com/apachecn/o…项目仓库：https://github.com/apachecn/o…认领：51/51，翻译：19/51。章节贡献者进度1. 简介@wstone00111.1 OpenCV-Python教程简介-100%1.2 安装OpenCV—Python-100%2. GUI功能@ranxx2.1 图像入门-100%2.2 视频入门-100%2.3 绘图功能-100%2.4 鼠标作为画笔-100%2.5 作为调色板的跟踪栏-100%3. 核心操作@luxinfeng3.1 图像基本操作-100%3.2 图像的算术运算-100%3.3 性能测量和改进技术-100%4. 图像处理@friedhelm7394.1 更改颜色空间-100%4.2 图像的几何变换-100%4.3 图像阈值-100%4.4 平滑图像-4.5 形态转换-4.6 图像梯度-4.7 Canny边缘检测-4.8 影像金字塔-4.9 轮廓-4.10 直方图-4.11 图像转换-4.12 模板匹配-4.13 霍夫线变换-4.14 霍夫圆变换-4.15 基于分水岭算法的图像分割-基于GrabCut算法的交互式前景提取-5. 特征检测和描述@3lackrush5.1 了解功能-100%5.2 Harris角点检测-5.3 Shi-Tomasi角点检测和追踪的良好特征-5.4 SIFT简介（尺度不变特征变换）-5.5 SURF简介（加速鲁棒特性）-5.6 角点检测的FAST算法-5.7 简介（二进制鲁棒独立基本特征）-5.8 ORB（定向快速和快速旋转）-5.9 特征匹配-5.10 特征匹配+ Homography查找对象-6. 视频分析@xmmmmmovo6.1 Meanshift和Camshift-100%6.2 光流-100%6.3 背景减法-100%7. 相机校准和3D重建@xmmmmmovo 7.1 相机校准-7.2 姿势估计-7.3 极线几何-7.4 立体图像的深度图-8. 机器学习@wstone00118.1 K-最近邻-8.2 支持向量机（SVM）-8.3 K-Means聚类-9. 计算摄影@ranxx9.1 图像去噪-9.2 图像修复-9.3 高动态范围（HDR）-10. 目标检测@jiangzhonglian 10.1 使用Haar Cascades进行人脸检测-100%11. OpenCV-Python绑定@daidai21 11.1 OpenCV-Python绑定如何工作？-100%翻译征集要求：机器学习/数据科学相关或者编程相关原文必须在互联网上开放不能只提供 PDF 格式（我们实在不想把精力都花在排版上）请先搜索有没有人翻译过请回复本文。赞助我们 ...

【主页】 apachecn.org【Github】@ApacheCN暂时下线: 社区暂时下线: cwiki 知识库自媒体平台微博：@ApacheCN知乎：@ApacheCNCSDN简书OSChina博客园We are ApacheCN Open Source Organization, not ASF! We are fans of AI, and have no relationship with ASF!合作or侵权，请联系【fonttian】fonttian@gmail.com | 请抄送一份到 apachecn@163.comPyTorch 1.0 中文文档参与方式：https://github.com/apachecn/p…整体进度：https://github.com/apachecn/p…项目仓库：https://github.com/apachecn/p…教程部分：认领：37/37，翻译：32/37；文档部分：认领：37/39，翻译：34/39章节贡献者进度教程部分–Deep Learning with PyTorch: A 60 Minute Blitz@bat67100%What is PyTorch?@bat67100%Autograd: Automatic Differentiation@bat67100%Neural Networks@bat67100%Training a Classifier@bat67100%Optional: Data Parallelism@bat67100%Data Loading and Processing Tutorial@yportne13100%Learning PyTorch with Examples@bat67100%Transfer Learning Tutorial@jiangzhonglian100%Deploying a Seq2Seq Model with the Hybrid Frontend@cangyunye100%Saving and Loading Models@bruce1408 What is torch.nn really?@lhc741100%Finetuning Torchvision Models@ZHHAYO100%Spatial Transformer Networks Tutorial@PEGASUS1993100%Neural Transfer Using PyTorch@bdqfork100%Adversarial Example Generation@cangyunye100%Transfering a Model from PyTorch to Caffe2 and Mobile using ONNX@PEGASUS1993100%Chatbot Tutorial@a625687551100%Generating Names with a Character-Level RNN@hhxx2015100%Classifying Names with a Character-Level RNN@hhxx2015100%Deep Learning for NLP with Pytorch@bruce1408 Introduction to PyTorch@guobaoyo100%Deep Learning with PyTorch@bdqfork100%Word Embeddings: Encoding Lexical Semantics@sight007100%Sequence Models and Long-Short Term Memory Networks@ETCartman100%Advanced: Making Dynamic Decisions and the Bi-LSTM CRF@JohnJiangLA Translation with a Sequence to Sequence Network and Attention@mengfu188100%DCGAN Tutorial@wangshuai9517100%Reinforcement Learning (DQN) Tutorial@friedhelm739100%Creating Extensions Using numpy and scipy@cangyunye100%Custom C++ and CUDA Extensions@Lotayou Extending TorchScript with Custom C++ Operators@cloudyyyyy Writing Distributed Applications with PyTorch@firdameng100%PyTorch 1.0 Distributed Trainer with Amazon AWS@yportne13100%ONNX Live Tutorial@PEGASUS1993100%Loading a PyTorch Model in C++@talengu100%Using the PyTorch C++ Frontend@solerji100%文档部分–Autograd mechanics@PEGASUS1993100%Broadcasting semantics@PEGASUS1993100%CUDA semantics@jiangzhonglian100%Extending PyTorch@PEGASUS1993100%Frequently Asked Questions@PEGASUS1993100%Multiprocessing best practices@cvley100%Reproducibility@WyattHuang1 Serialization semantics@yuange250100%Windows FAQ@PEGASUS1993100%torch torch.Tensor@hijkzzz100%Tensor Attributes@yuange250100%Type Info@PEGASUS1993100%torch.sparse@hijkzzz100%torch.cuda@bdqfork100%torch.Storage@yuange250100%torch.nn@yuange250 torch.nn.functional@hijkzzz100%torch.nn.init@GeneZC100%torch.optim@qiaokuoyuan Automatic differentiation package - torch.autograd@gfjiangly100%Distributed communication package - torch.distributed@univeryinli100%Probability distributions - torch.distributions@hijkzzz100%Torch Script@keyianpai100%Multiprocessing package - torch.multiprocessing@hijkzzz100%torch.utils.bottleneck@belonHan100%torch.utils.checkpoint@belonHan100%torch.utils.cpp_extension@belonHan100%torch.utils.data@BXuan694100%torch.utils.dlpack@kunwuz100%torch.hub@kunwuz100%torch.utils.model_zoo@BXuan694100%torch.onnx@guobaoyo100%Distributed communication package (deprecated) - torch.distributed.deprecated torchvision Reference@BXuan694100%torchvision.datasets@BXuan694100%torchvision.models@BXuan694100%torchvision.transforms@BXuan694100%torchvision.utils@BXuan694100%HBase 3.0 中文参考指南参与方式：https://github.com/apachecn/h…整体进度：https://github.com/apachecn/h…项目仓库：https://github.com/apachecn/h…认领：13/31，翻译：9/31章节译者进度Preface@xixici100%Getting Started@xixici100%Apache HBase Configuration@xixici100%Upgrading@xixici100%The Apache HBase Shell@xixici100%Data Model@Winchester-Yi HBase and Schema Design@RaymondCode100%RegionServer Sizing Rules of Thumb HBase and MapReduce@BridgetLai Securing Apache HBase Architecture@RaymondCode In-memory Compaction Backup and Restore Synchronous Replication Apache HBase APIs@xixici100%Apache HBase External APIs@xixici100%Thrift API and Filter Language@xixici100%HBase and Spark@TsingJyujing Apache HBase Coprocessors Apache HBase Performance Tuning Troubleshooting and Debugging Apache HBase Apache HBase Case Studies Apache HBase Operational Management Building and Developing Apache HBase Unit Testing HBase Applications Protobuf in HBase Procedure Framework (Pv2): HBASE-12439 AMv2 Description for Devs ZooKeeper Community Appendix AirFlow 中文文档参与方式：https://github.com/apachecn/a…整体进度：https://github.com/apachecn/a…项目仓库：https://github.com/apachecn/a…认领：25/30，翻译：24/30。章节贡献者进度1 项目@zhongjiajie100%2 协议-100%3 快速开始@ImPerat0R_100%4 安装@Thinking Chen100%5 教程@ImPerat0R_100%6 操作指南@ImPerat0R_100%7 设置配置选项@ImPerat0R_100%8 初始化数据库后端@ImPerat0R_100%9 使用操作器@ImPerat0R_100%10 管理连接@ImPerat0R_100%11 保护连接@ImPerat0R_100%12 写日志@ImPerat0R_100%13 使用Celery扩大规模@ImPerat0R_100%14 使用Dask扩展@ImPerat0R_100%15 使用Mesos扩展（社区贡献）@ImPerat0R_100%16 使用systemd运行Airflow@ImPerat0R_100%17 使用upstart运行Airflow@ImPerat0R_100%18 使用测试模式配置@ImPerat0R_100%19 UI /截图@ImPerat0R_100%20 概念@ImPerat0R_100%21 数据分析@ImPerat0R_100%22 命令行接口@ImPerat0R_100%23 调度和触发器@Ray100%24 插件@ImPerat0R_100%25 安全 26 时区 27 实验性 Rest API@ImPerat0R_100%28 集成 29 Lineage 30 常见问题@zhongjiajie 31 API 参考 OpenCV 4.0 中文文档参与方式：https://github.com/apachecn/o…整体进度：https://github.com/apachecn/o…项目仓库：https://github.com/apachecn/o…认领：47/51，翻译：17/51。章节贡献者进度1. 简介@wstone00111.1 OpenCV-Python教程简介-100%1.2 安装OpenCV—Python-2. GUI功能@ranxx2.1 图像入门-100%2.2 视频入门-100%2.3 绘图功能-100%2.4 鼠标作为画笔-100%2.5 作为调色板的跟踪栏-100%3. 核心操作@luxinfeng3.1 图像基本操作-100%3.2 图像的算术运算-100%3.3 性能测量和改进技术-100%4. 图像处理@friedhelm7394.1 更改颜色空间-100%4.2 图像的几何变换-100%4.3 图像阈值-4.4 平滑图像-4.5 形态转换-4.6 图像梯度-4.7 Canny边缘检测-4.8 影像金字塔-4.9 轮廓-4.10 直方图-4.11 图像转换-4.12 模板匹配-4.13 霍夫线变换-4.14 霍夫圆变换-4.15 基于分水岭算法的图像分割-基于GrabCut算法的交互式前景提取-5. 特征检测和描述@3lackrush5.1 了解功能-100%5.2 Harris角点检测-5.3 Shi-Tomasi角点检测和追踪的良好特征-5.4 SIFT简介（尺度不变特征变换）-5.5 SURF简介（加速鲁棒特性）-5.6 角点检测的FAST算法-5.7 简介（二进制鲁棒独立基本特征）-5.8 ORB（定向快速和快速旋转）-5.9 特征匹配-5.10 特征匹配+ Homography查找对象-6. 视频分析@xmmmmmovo6.1 Meanshift和Camshift-100%6.2 光流-100%6.3 背景减法-100%7. 相机校准和3D重建 7.1 相机校准 7.2 姿势估计 7.3 极线几何 7.4 立体图像的深度图 8. 机器学习@wstone00118.1 K-最近邻-8.2 支持向量机（SVM）-8.3 K-Means聚类-9. 计算摄影@ranxx9.1 图像去噪-9.2 图像修复-9.3 高动态范围（HDR）-10. 目标检测@jiangzhonglian 10.1 使用Haar Cascades进行人脸检测-100%11. OpenCV-Python绑定@daidai21 11.1 OpenCV-Python绑定如何工作？-100%UCB CS61b：Java 中的数据结构参与方式：https://github.com/apachecn/c…整体进度：https://github.com/apachecn/c…项目仓库：https://github.com/apachecn/c…认领：2/12，翻译：1/12。标题译者进度一、算法复杂度@leader402二、抽象数据类型@Allenyep100%三、满足规范 四、序列和它们的实现 五、树 六、搜索树 七、哈希 八、排序和选择 九、平衡搜索 十、并发和同步 十一、伪随机序列 十二、图 UCB Prob140：面向数据科学的概率论参与方式：https://github.com/apachecn/p…整体进度：https://github.com/apachecn/p…项目仓库：https://github.com/apachecn/p…认领：23/25，翻译：19/25。标题译者翻译进度一、基础飞龙100%二、计算几率飞龙100%三、随机变量飞龙100%四、事件之间的关系@biubiubiuboomboomboom100%五、事件集合@PEGASUS1993>0%六、随机计数@viviwong100%七、泊松化@YAOYI626100%八、期望@PEGASUS199350%九、条件（续）@YAOYI626100%十、马尔科夫链喵十八100%十一、马尔科夫链（续）喵十八100%十二、标准差缺只萨摩 100%十三、方差和协方差缺只萨摩 100%十四、中心极限定理喵十八100%十五、连续分布@ThunderboltSmile十六、变换十七、联合密度@Winchester-Yi100%十八、正态和 Gamma 族@Winchester-Yi100%十九、和的分布平淡的天100%二十、估计方法平淡的天100%二十一、Beta 和二项@lvzhetx100%二十二、预测 50%二十三、联合正态随机变量@JUNE951234二十四、简单线性回归@ThomasCai100%二十五、多元回归@lanhaixuan100%翻译征集要求：机器学习/数据科学相关或者编程相关原文必须在互联网上开放不能只提供 PDF 格式（我们实在不想把精力都花在排版上）请先搜索有没有人翻译过请回复本文。赞助我们 ...

【主页】 apachecn.org【Github】@ApacheCN暂时下线: 社区暂时下线: cwiki 知识库自媒体平台微博：@ApacheCN知乎：@ApacheCNCSDN简书OSChina博客园We are ApacheCN Open Source Organization, not ASF! We are fans of AI, and have no relationship with ASF!合作or侵权，请联系【fonttian】<fonttian@gmail.com> | 请抄送一份到 <apachecn@163.com>特色项目PyTorch 0.2/0.3/0.4/1.0 中文文档和教程Sklearn 与 TensorFlow 机器学习实用指南人工智能/机器学习/数据科学比赛系列Kaggle 项目实战教程：文档 + 代码 + 视频数据科学比赛收集平台LeetCode，HackRank，剑指 offer，经典算法实现UCB CS/DS 系列课本UCB CS61a 课本：SICP Python 描述UCB CS61b 课本：Java 中的数据结构UCB Data8 课本：计算与推断思维UCB Prob140 课本：面向数据科学的概率论UCB DS100 课本：数据科学的原理与技巧Numpy 技术栈中文文档NumPy 中文文档Pandas 中文文档Matplotlib 中文文档Sklearn 0.19 中文文档statsmodels 中文文档Java 基础Java 编程思想Java 从0～1个人笔记大数据Spark 2.2.0 中文文档Storm 1.1.0 中文文档Kafka 1.0.0 中文文档Beam 中文文档Zeppelin 0.7.2 中文文档Elasticsearch 5.4 中文文档Kibana 5.2 中文文档Kudu 1.4.0 中文文档Spring Boot 1.5.2 中文文档Airflow 中文文档HBase 3.0 中文参考指南Flink 1.7 中文文档区块链Solidity 中文文档数学笔记MIT 18.06 线性代数笔记Python 数据科学NumPy 中文文档Pandas 中文文档Matplotlib 中文文档UCB Data8 课本：计算与推断思维UCB Prob140 课本：面向数据科学的概率论UCB DS100 课本：数据科学的原理与技巧利用 Python 进行数据分析 · 第 2 版fast.ai 数值线性代数讲义 v2Pandas Cookbook 带注释源码statsmodels 中文文档数据科学 IPython 笔记本CS 教程LeetCode，HackRank，剑指 offer，经典算法实现GeeksForGeeks 翻译计划UCB CS61a 课本：SICP Python 描述UCB CS61b 课本：Java 中的数据结构数据结构思维中国大学 MOOC 计算机操作系统笔记简单数据结构实现AI 教程AILearning - 机器学习实战Sklearn 与 TensorFlow 机器学习实用指南面向机器学习的特征工程Python 数据分析与挖掘实战（带注释源码）SciPyCon 2018 Sklearn 教程TensorFlow 学习指南fast.ai 机器学习和深度学习中文笔记HackCV 网站文章翻译台湾大学林轩田机器学习笔记Scikit-learn 秘籍写给人类的机器学习数据科学和人工智能技术笔记AI 文档Sklearn 0.19 中文文档PyTorch 0.2/0.3/0.4/1.0 中文文档和教程XGBoost 中文文档LightGBM 中文文档FastText 中文文档Gensim 中文文档OpenCV 4.0 中文文档AI 比赛Kaggle 项目实战教程：文档 + 代码 + 视频数据科学比赛收集平台其它独立开发/自由职业/远程工作资源列表通往财富自由之路精细笔记5 分钟商学院精细笔记翻译征集要求：机器学习/数据科学相关或者编程相关原文必须在互联网上开放不能只提供 PDF 格式（我们实在不想把精力都花在排版上）请先搜索有没有人翻译过请回复本文。赞助我们 ...

什么是PyTorch？ PyTorch是Facebook人工智能团队开发的一个机器学习和深度学习工具，用于处理大规模图像分析，包括物体检测，分割与分类。但是它的功能不仅限于此。它与其它深度学习框架结合，能够完成复杂的算法。PyTorch用Python和C++编写。 PyTorch属于深度学习框架中的重要一员，与TensorFlow, Keras, Theano等其它深度学习框架不同，它是动态计算图模式，其应用模型支持在运行过程中根据运行参数动态改变，而其它框架都是静态计算图模式，其模型在运行之前就已经确定。以下是各个深度学习框架的热度对比:关于各个深度学习框架的对比，可以参考网址：Comparison of deep learning software 。 PyTorch是使用GPU和CPU优化的深度学习张量库。 下面，我们将一起来学习PyTorch中向量（Tensor）的相关操作。安装与运行 PyTorch的安装十分简单，需要用pip安装即可：pip3 install torchpip3 install torchvision其中torchvision包含了一些torch内置的图片与视频数据集。 用以下的Python代码可以输出安装的PyTorch版本信息：import torchprint(torch.version.version)在笔者的电脑上，输出的结果如下：1.0.1.post2向量的基本操作导入模块检测是否为PyTorch中的向量 is_tensor()函数可以检测某个序列是否为PyTorch中的向量，is_storage()可以检测某个序列是否被存储为PyTorch中的向量。 可以看到，Python中的列表并不是PyTorch中的向量，也不会被存储为PyTorch中的向量。那么，如何创建PyTorch中的向量呢？创建随机向量 利用randn()函数可以创建随机向量，随机数为01的随机浮点数，可以指定创建的向量的维数。可以看到，我们创建了123维的向量，用size()函数可以查看向量的维数情况，用numel()函数可以查看向量中的所有元素个数。创建零向量 利用zeros()函数可以创建零向量，即所有元素均为零的向量，只需指定向量的维数即可。在上面，我们创建了4*4的零向量。创建单位向量 利用eye()函数可以创建单位向量，即主对角元素为1，其余元素均为零的向量，只需指定向量的维数即可。当二维向量的行数与列数不一样时，主对角元素为1，其余为0。从numpy中创建向量 PyTorch支持直接从numpy中创建向量，这为PyTorch和numpy提供了无缝对接，这也是PyTorch的一个优势。 当然，PyTorch也可以将向量转化为numpy中的ndarrays.Tensor函数创建向量 可以利用Tensor()直接创建向量。linspace与logspace创建向量 linspace(tart, end, steps=100, out=None)通过指定开始值、终值和元素个数创建表示等差数列的一维数组，可以通过endpoint参数指定是否包含终值，默认值为True，即包含终值。 logspace(tart, end, steps=100, out=None)返回一个1维张量，包含在区间10exp(start)和10exp(end)上以对数刻度均匀间隔的 steps个点。创建均匀分布向量 rand()函数可以创建指定维数的满足均匀分布的向量。随机整数排列向量 randperm(n, out=None) ,给定参数n，返回一个从0 到n -1 的随机整数排列。等差数列向量 arange(start, end, step=1, out=None) , 返回一个1维张量，包含从start到end，以step为步长的一组序列值(默认步长为1)。寻找最大值、最小组 argmin()和argmax()函数可以寻找向量所在的最小值和最大值的下标，0表示沿着行查找，1表示沿着列查找。向量拼接 cat()函数在给定维度上对输入的张量序列seq 进行连接操作，默认的维度为0，即按行拼接。向量分块 chunk(tensor, chunks, dim=0)函数在给定维度(轴)上将输入张量进行分块，默认为0，即按行进行分块。gather()函数 gather(input, dim, index, out=None), 沿给定轴dim，将输入索引张量index指定位置的值进行聚合。gather()函数理解起来比较困难，先看例子，再解释：gather的作用是这样的，index是索引，具体是行还是列的索引要看前面dim ，比如对于我们的例子, [[11, 12], [23, 24]], 指定dim=1，也就是横向，那么索引就是列号。index的大小就是输出的大小，所以比如index是[[0,0], [1,0]]，那么看index第一行，0列指的是11，同理，第二行为1, 0 , 这样就是[24, 23]，参考这样的解释看上面的输出结果，即可理解gather的含义。索引 index_select(input, dim, index, out=None) ，沿着指定维度对输入进行切片，取index中指定的相应项(index为一个LongTensor)，然后返回到一个新的张量，返回的张量与原始张量_Tensor_有相同的维度(在指定轴上)。split()函数 split(tensor, split_size, dim=0), 将输入张量分割成相等形状的chunks（如果可分）。 如果沿指定维的张量形状大小不能被split_size整分， 则最后一个分块会小于其它分块。向量转置 二维向量的转置可以用t()或transpos(1, 0)实现。unbind() unbind(tensor, dim=0), 移除指定维后，返回一个元组，包含了沿着指定维切片后的各个切片，默认维度为1，表示行，1表示列。判断是否为零元素 nonzero()函数可以判断向量中的元素是否为0.向量运算 以下将演示几种常见的矩阵运算。矩阵的点乘与矩阵乘法总结 本文的github地址为：https://github.com/percent4/P… 。注意：不妨了解下笔者的微信公众号： Python爬虫与算法（微信号为：easy_web_scrape）， 欢迎大家关注 ...

【主页】 apachecn.org【Github】@ApacheCN暂时下线: 社区暂时下线: cwiki 知识库自媒体平台微博：@ApacheCN知乎：@ApacheCNCSDN简书OSChina博客园我们不是 Apache 的官方组织/机构/团体，只是 Apache 技术栈（以及 AI）的爱好者！合作or侵权，请联系【fonttian】fonttian@gmail.com | 请抄送一份到 apachecn@163.comPyTorch 1.0 中文文档参与方式：https://github.com/apachecn/p…整体进度：https://github.com/apachecn/p…项目仓库：https://github.com/apachecn/p…教程部分：认领：36/37，翻译：29/37；文档部分：认领：34/39，翻译：23/39章节贡献者进度教程部分–Deep Learning with PyTorch: A 60 Minute Blitz@bat67100%What is PyTorch?@bat67100%Autograd: Automatic Differentiation@bat67100%Neural Networks@bat67100%Training a Classifier@bat67100%Optional: Data Parallelism@bat67100%Data Loading and Processing Tutorial@yportne13100%Learning PyTorch with Examples@bat67100%Transfer Learning Tutorial@jiangzhonglian100%Deploying a Seq2Seq Model with the Hybrid Frontend@cangyunye100%Saving and Loading Models@sfyumi What is torch.nn really?@lhc741100%Finetuning Torchvision Models@ZHHAYO100%Spatial Transformer Networks Tutorial@PEGASUS1993100%Neural Transfer Using PyTorch@bdqfork100%Adversarial Example Generation@cangyunye100%Transfering a Model from PyTorch to Caffe2 and Mobile using ONNX@PEGASUS1993100%Chatbot Tutorial@a625687551100%Generating Names with a Character-Level RNN@hhxx2015100%Classifying Names with a Character-Level RNN@hhxx2015100%Deep Learning for NLP with Pytorch@BreezeHavana Introduction to PyTorch@guobaoyo100%Deep Learning with PyTorch@bdqfork100%Word Embeddings: Encoding Lexical Semantics@sight007100%Sequence Models and Long-Short Term Memory Networks@ETCartman100%Advanced: Making Dynamic Decisions and the Bi-LSTM CRF@JohnJiangLA Translation with a Sequence to Sequence Network and Attention@mengfu188100%DCGAN Tutorial@wangshuai9517 Reinforcement Learning (DQN) Tutorial@BreezeHavana Creating Extensions Using numpy and scipy@cangyunye100%Custom C++ and CUDA Extensions@Lotayou Extending TorchScript with Custom C++ Operators Writing Distributed Applications with PyTorch@firdameng PyTorch 1.0 Distributed Trainer with Amazon AWS@yportne13100%ONNX Live Tutorial@PEGASUS1993100%Loading a PyTorch Model in C++@talengu100%Using the PyTorch C++ Frontend@solerji100%文档部分–Autograd mechanics@PEGASUS1993100%Broadcasting semantics@PEGASUS1993100%CUDA semantics@jiangzhonglian100%Extending PyTorch@PEGASUS1993 Frequently Asked Questions@PEGASUS1993100%Multiprocessing best practices@cvley100%Reproducibility@WyattHuang1 Serialization semantics@yuange250100%Windows FAQ@PEGASUS1993100%torch@ZHHAYO torch.Tensor@hijkzzz100%Tensor Attributes@yuange250100%Type Info@PEGASUS1993100%torch.sparse@hijkzzz100%torch.cuda@bdqfork100%torch.Storage@yuange250100%torch.nn@yuange250 torch.nn.functional@hijkzzz100%torch.nn.init@GeneZC100%torch.optim@qiaokuoyuan Automatic differentiation package - torch.autograd@gfjiangly Distributed communication package - torch.distributed Probability distributions - torch.distributions@hijkzzz Torch Script Multiprocessing package - torch.multiprocessing@hijkzzz100%torch.utils.bottleneck@belonHan torch.utils.checkpoint@belonHan torch.utils.cpp_extension@belonHan torch.utils.data@BXuan694 torch.utils.dlpack torch.hub torch.utils.model_zoo@BXuan694100%torch.onnx@guobaoyo100%Distributed communication package (deprecated) - torch.distributed.deprecated torchvision Reference@BXuan694100%torchvision.datasets@BXuan694100%torchvision.models@BXuan694100%torchvision.transforms@BXuan694100%torchvision.utils@BXuan694100%HBase 3.0 中文参考指南参与方式：https://github.com/apachecn/h…整体进度：https://github.com/apachecn/h…项目仓库：https://github.com/apachecn/h…认领：3/31，翻译：1/31章节译者进度Preface Getting Started Apache HBase Configuration Upgrading The Apache HBase Shell Data Model@Winchester-Yi HBase and Schema Design@RaymondCode100%RegionServer Sizing Rules of Thumb HBase and MapReduce Securing Apache HBase Architecture In-memory Compaction Backup and Restore Synchronous Replication Apache HBase APIs Apache HBase External APIs Thrift API and Filter Language HBase and Spark@TsingJyujing Apache HBase Coprocessors Apache HBase Performance Tuning Troubleshooting and Debugging Apache HBase Apache HBase Case Studies Apache HBase Operational Management Building and Developing Apache HBase Unit Testing HBase Applications Protobuf in HBase Procedure Framework (Pv2): HBASE-12439 AMv2 Description for Devs ZooKeeper Community Appendix AirFlow 中文文档参与方式：https://github.com/apachecn/a…整体进度：https://github.com/apachecn/a…项目仓库：https://github.com/apachecn/a…认领：24/30，翻译：24/30。章节贡献者进度1 项目@zhongjiajie100%2 协议-100%3 快速开始@ImPerat0R_100%4 安装@Thinking Chen100%5 教程@ImPerat0R_100%6 操作指南@ImPerat0R_100%7 设置配置选项@ImPerat0R_100%8 初始化数据库后端@ImPerat0R_100%9 使用操作器@ImPerat0R_100%10 管理连接@ImPerat0R_100%11 保护连接@ImPerat0R_100%12 写日志@ImPerat0R_100%13 使用Celery扩大规模@ImPerat0R_100%14 使用Dask扩展@ImPerat0R_100%15 使用Mesos扩展（社区贡献）@ImPerat0R_100%16 使用systemd运行Airflow@ImPerat0R_100%17 使用upstart运行Airflow@ImPerat0R_100%18 使用测试模式配置@ImPerat0R_100%19 UI /截图@ImPerat0R_100%20 概念@ImPerat0R_100%21 数据分析@ImPerat0R_100%22 命令行接口@ImPerat0R_100%23 调度和触发器@Ray100%24 插件@ImPerat0R_100%25 安全 26 时区 27 实验性 Rest API@ImPerat0R_100%28 集成 29 Lineage 30 常见问题 31 API 参考 OpenCV 4.0 中文文档参与方式：https://github.com/apachecn/o…整体进度：https://github.com/apachecn/o…项目仓库：https://github.com/apachecn/o…认领：0/51，翻译：0/51。章节贡献者进度1. 简介 1.1 OpenCV-Python教程简介 1.2 安装OpenCV—Python 2. GUI功能 2.1 图像入门 2.2 视频入门 2.3 绘图功能 2.4 鼠标作为画笔 2.5 作为调色板的跟踪栏 3. 核心操作 3.1 图像基本操作 3.2 图像的算术运算 3.3 性能测量和改进技术 4. 图像处理 4.1 更改颜色空间 4.2 图像的几何变换 4.3 图像阈值 4.4 平滑图像 4.5 形态转换 4.6 图像梯度 4.7 Canny边缘检测 4.8 影像金字塔 4.9 轮廓 4.10 直方图 4.11 图像转换 4.12 模板匹配 4.13 霍夫线变换 4.14 霍夫圆变换 4.15 基于分水岭算法的图像分割 基于GrabCut算法的交互式前景提取 5. 特征检测和描述 5.1 了解功能 5.2 Harris角点检测 5.3 Shi-Tomasi角点检测和追踪的良好特征 5.4 SIFT简介（尺度不变特征变换） 5.5 SURF简介（加速鲁棒特性） 5.6 角点检测的FAST算法 5.7 简介（二进制鲁棒独立基本特征） 5.8 ORB（定向快速和快速旋转） 5.9 特征匹配 5.10 特征匹配+ Homography查找对象 6. 视频分析 6.1 Meanshift和Camshift 6.2 光流 6.3 背景减法 7. 相机校准和3D重建 7.1 相机校准 7.2 姿势估计 7.3 极线几何 7.4 立体图像的深度图 8. 机器学习 8.1 K-最近邻 8.2 支持向量机（SVM） 8.3 K-Means聚类 9. 计算摄影 9.1 图像去噪 9.2 图像修复 9.3 高动态范围（HDR） 10. 目标检测 10.1 使用Haar Cascades进行人脸检测 11. OpenCV-Python绑定 11.1 OpenCV-Python绑定如何工作？ UCB CS61b：Java 中的数据结构参与方式：https://github.com/apachecn/c…整体进度：https://github.com/apachecn/c…项目仓库：https://github.com/apachecn/c…认领：0/12，翻译：0/12。标题译者进度一、算法复杂度 二、抽象数据类型 三、满足规范 四、序列和它们的实现 五、树 六、搜索树 七、哈希 八、排序和选择 九、平衡搜索 十、并发和同步 十一、伪随机序列 十二、图 UCB Prob140：面向数据科学的概率论参与方式：https://github.com/apachecn/p…整体进度：https://github.com/apachecn/p…项目仓库：https://github.com/apachecn/p…认领：23/25，翻译：19/25。标题译者翻译进度一、基础飞龙100%二、计算几率飞龙100%三、随机变量飞龙100%四、事件之间的关系@biubiubiuboomboomboom100%五、事件集合@PEGASUS1993>0%六、随机计数@viviwong100%七、泊松化@YAOYI626100%八、期望@PEGASUS199350%九、条件（续）@YAOYI626100%十、马尔科夫链喵十八100%十一、马尔科夫链（续）喵十八100%十二、标准差缺只萨摩 100%十三、方差和协方差缺只萨摩 100%十四、中心极限定理喵十八100%十五、连续分布@ThunderboltSmile十六、变换十七、联合密度@Winchester-Yi100%十八、正态和 Gamma 族@Winchester-Yi100%十九、和的分布平淡的天100%二十、估计方法平淡的天100%二十一、Beta 和二项@lvzhetx100%二十二、预测@lvzhetx50%二十三、联合正态随机变量二十四、简单线性回归@ThomasCai100%二十五、多元回归@lanhaixuan100%翻译征集要求：机器学习/数据科学相关或者编程相关原文必须在互联网上开放不能只提供 PDF 格式（我们实在不想把精力都花在排版上）请先搜索有没有人翻译过请回复本文。赞助我们 ...

【主页】 apachecn.org【Github】@ApacheCN暂时下线: 社区暂时下线: cwiki 知识库自媒体平台微博：@ApacheCN知乎：@ApacheCNCSDN简书OSChina博客园我们不是 Apache 的官方组织/机构/团体，只是 Apache 技术栈（以及 AI）的爱好者！合作or侵权，请联系【fonttian】<fonttian@gmail.com> | 请抄送一份到 <apachecn@163.com>PyTorch 1.0 中文文档和教程教程部分：认领：36/37，翻译：28/37；文档部分：认领：29/39，翻译：15/39参与方式：https://github.com/apachecn/p…整体进度：https://github.com/apachecn/p…项目仓库：https://github.com/apachecn/p…章节贡献者进度教程部分–Deep Learning with PyTorch: A 60 Minute Blitz@bat67100%What is PyTorch?@bat67100%Autograd: Automatic Differentiation@bat67100%Neural Networks@bat67100%Training a Classifier@bat67100%Optional: Data Parallelism@bat67100%Data Loading and Processing Tutorial@yportne13100%Learning PyTorch with Examples@bat67100%Transfer Learning Tutorial@jiangzhonglian100%Deploying a Seq2Seq Model with the Hybrid Frontend@cangyunye100%Saving and Loading Models@sfyumi What is <cite>torch.nn</cite> really?@lhc741 Finetuning Torchvision Models@ZHHAYO100%Spatial Transformer Networks Tutorial@PEGASUS1993100%Neural Transfer Using PyTorch@bdqfork100%Adversarial Example Generation@cangyunye100%Transfering a Model from PyTorch to Caffe2 and Mobile using ONNX@PEGASUS1993100%Chatbot Tutorial@a625687551100%Generating Names with a Character-Level RNN@hhxx2015100%Classifying Names with a Character-Level RNN@hhxx2015100%Deep Learning for NLP with Pytorch@BreezeHavana Introduction to PyTorch@guobaoyo100%Deep Learning with PyTorch@bdqfork100%Word Embeddings: Encoding Lexical Semantics@sight007100%Sequence Models and Long-Short Term Memory Networks@ETCartman100%Advanced: Making Dynamic Decisions and the Bi-LSTM CRF@JohnJiangLA Translation with a Sequence to Sequence Network and Attention@mengfu188100%DCGAN Tutorial@wangshuai9517 Reinforcement Learning (DQN) Tutorial@BreezeHavana Creating Extensions Using numpy and scipy@cangyunye100%Custom C++ and CUDA Extensions@Lotayou Extending TorchScript with Custom C++ Operators Writing Distributed Applications with PyTorch@firdameng PyTorch 1.0 Distributed Trainer with Amazon AWS@yportne13100%ONNX Live Tutorial@PEGASUS1993100%Loading a PyTorch Model in C++@talengu100%Using the PyTorch C++ Frontend@solerji100%文档部分–Autograd mechanics@PEGASUS1993100%Broadcasting semantics@PEGASUS1993100%CUDA semantics@jiangzhonglian100%Extending PyTorch@PEGASUS1993 Frequently Asked Questions@PEGASUS1993 Multiprocessing best practices@cvley100%Reproducibility@WyattHuang1 Serialization semantics@yuange250100%Windows FAQ@PEGASUS1993 torch@ZHHAYO torch.Tensor@hijkzzz100%Tensor Attributes@yuange250100%Type Info@PEGASUS1993100%torch.sparse@hijkzzz100%torch.cuda@bdqfork100%torch.Storage@yuange250100%torch.nn@yuange250 torch.nn.functional@hijkzzz100%torch.nn.init@GeneZC100%torch.optim@qiaokuoyuan Automatic differentiation package - torch.autograd@gfjiangly Distributed communication package - torch.distributed Probability distributions - torch.distributions@hijkzzz Torch Script Multiprocessing package - torch.multiprocessing@hijkzzz100%torch.utils.bottleneck torch.utils.checkpoint torch.utils.cpp_extension torch.utils.data torch.utils.dlpack torch.hub torch.utils.model_zoo torch.onnx@guobaoyo100%Distributed communication package (deprecated) - torch.distributed.deprecated torchvision Reference@BXuan694 torchvision.datasets@BXuan694 torchvision.models@BXuan694 torchvision.transforms@BXuan694 torchvision.utils@BXuan694 HBase 3.0 中文参考指南认领：2/31，翻译：0/31参与方式：https://github.com/apachecn/h…整体进度：https://github.com/apachecn/h…项目仓库：https://github.com/apachecn/h…章节译者进度Preface Getting Started Apache HBase Configuration Upgrading The Apache HBase Shell Data Model HBase and Schema Design@RaymondCode RegionServer Sizing Rules of Thumb HBase and MapReduce Securing Apache HBase Architecture In-memory Compaction Backup and Restore Synchronous Replication Apache HBase APIs Apache HBase External APIs Thrift API and Filter Language HBase and Spark@TsingJyujing Apache HBase Coprocessors Apache HBase Performance Tuning Troubleshooting and Debugging Apache HBase Apache HBase Case Studies Apache HBase Operational Management Building and Developing Apache HBase Unit Testing HBase Applications Protobuf in HBase Procedure Framework (Pv2): HBASE-12439 AMv2 Description for Devs ZooKeeper Community Appendix Airflow 中文文档认领：23/30，翻译：23/30。参与方式：https://github.com/apachecn/a…整体进度：https://github.com/apachecn/a…项目仓库：https://github.com/apachecn/a…章节贡献者进度1 项目 2 协议-100%3 快速开始@ImPerat0R_100%4 安装@Thinking Chen100%5 教程@ImPerat0R_100%6 操作指南@ImPerat0R_100%7 设置配置选项@ImPerat0R_100%8 初始化数据库后端@ImPerat0R_100%9 使用操作器@ImPerat0R_100%10 管理连接@ImPerat0R_100%11 保护连接@ImPerat0R_100%12 写日志@ImPerat0R_100%13 使用Celery扩大规模@ImPerat0R_100%14 使用Dask扩展@ImPerat0R_100%15 使用Mesos扩展（社区贡献）@ImPerat0R_100%16 使用systemd运行Airflow@ImPerat0R_100%17 使用upstart运行Airflow@ImPerat0R_100%18 使用测试模式配置@ImPerat0R_100%19 UI /截图@ImPerat0R_100%20 概念@ImPerat0R_100%21 数据分析@ImPerat0R_100%22 命令行接口@ImPerat0R_100%23 调度和触发器@Ray100%24 插件@ImPerat0R_100%25 安全 26 时区 27 实验性 Rest API@ImPerat0R_100%28 集成 29 Lineage 30 常见问题 31 API 参考 UCB CS61b Java 中的数据结构认领：0/12，翻译：0/12参与方式：https://github.com/apachecn/c…整体进度：https://github.com/apachecn/c…项目仓库：https://github.com/apachecn/c…标题译者进度一、算法复杂度 二、抽象数据类型 三、满足规范 四、序列和它们的实现 五、树 六、搜索树 七、哈希 八、排序和选择 九、平衡搜索 十、并发和同步 十一、伪随机序列 十二、图 UCB Prob140 面向数据科学的概率论认领：23/25，翻译：17/25参与方式：https://github.com/apachecn/p…整体进度：https://github.com/apachecn/p…项目仓库：https://github.com/apachecn/p…标题译者翻译进度一、基础飞龙100%二、计算几率飞龙100%三、随机变量飞龙100%四、事件之间的关系@biubiubiuboomboomboom100%五、事件集合@PEGASUS1993>0%六、随机计数@viviwong100%七、泊松化@YAOYI626100%八、期望@PEGASUS199350%九、条件（续）@YAOYI626100%十、马尔科夫链喵十八100%十一、马尔科夫链（续）喵十八100%十二、标准差缺只萨摩 100%十三、方差和协方差缺只萨摩 100%十四、中心极限定理喵十八100%十五、连续分布@ThunderboltSmile十六、变换十七、联合密度@Winchester-Yi100%十八、正态和 Gamma 族@Winchester-Yi100%十九、和的分布平淡的天100%二十、估计方法平淡的天100%二十一、Beta 和二项@lvzhetx100%二十二、预测@lvzhetx50%二十三、联合正态随机变量二十四、简单线性回归@ThomasCai100%二十五、多元回归@lanhaixuan100%翻译征集要求：机器学习/数据科学相关或者编程相关原文必须在互联网上开放不能只提供 PDF 格式（我们实在不想把精力都花在排版上）请先搜索有没有人翻译过请回复本文。赞助我们 ...

【主页】 apachecn.org【Github】@ApacheCN暂时下线: 社区暂时下线: cwiki 知识库自媒体平台微博：@ApacheCN知乎：@ApacheCNCSDN简书OSChina博客园我们不是 Apache 的官方组织/机构/团体，只是 Apache 技术栈（以及 AI）的爱好者！合作or侵权，请联系【fonttian】<fonttian@gmail.com> | 请抄送一份到 <apachecn@163.com>Java 基础Java 编程思想Java Web 和大数据Spark 2.2.0 中文文档Storm 1.1.0 中文文档Kafka 1.0.0 中文文档Beam 中文文档Zeppelin 0.7.2 中文文档Elasticsearch 5.4 中文文档Kibana 5.2 中文文档Kudu 1.4.0 中文文档Spring Boot 1.5.2 中文文档Airflow 中文文档区块链Solidity 中文文档数学笔记MIT 18.06 线性代数笔记Python 数据科学NumPy 中文文档Pandas 中文文档Matplotlib 中文文档UCB Data8 课本：计算与推断思维UCB Prob140 课本：面向数据科学的概率论UCB DS100 课本：数据科学的原理与技巧利用 Python 进行数据分析 · 第 2 版fast.ai 数值线性代数讲义 v2Pandas Cookbook 带注释源码statsmodels 中文文档数据科学 IPython 笔记本CS 教程LeetCode 中文文档GeeksForGeeks 翻译计划UCB CS61a 课本：SICP Python 描述UCB CS61b 课本：Java 中的数据结构数据结构思维中国大学 MOOC 计算机操作系统笔记简单数据结构实现AI 教程AILearning - 机器学习实战Sklearn 与 TensorFlow 机器学习实用指南面向机器学习的特征工程Python 数据分析与挖掘实战（带注释源码）SciPyCon 2018 Sklearn 教程TensorFlow 学习指南fast.ai 机器学习和深度学习中文笔记HackCV 网站文章翻译台湾大学林轩田机器学习笔记Scikit-learn 秘籍写给人类的机器学习数据科学和人工智能技术笔记AI 文档Sklearn 0.19 中文文档PyTorch 1.0 中文文档XGBoost 中文文档LightGBM 中文文档FastText 中文文档Gensim 中文文档AI 比赛Kaggle 项目实战教程：文档 + 代码 + 视频比赛收集平台其它独立开发/自由职业/远程工作资源列表通往财富自由之路精细笔记5 分钟商学院精细笔记 ...

摘要： 神经网络工具像一个黑匣子，无法知道它的中间是如何处理的。本文使用图片加代码的形式讲解CNN网络，并对每层的输出进行可视化，便于初学者理解，可以动手实践下哦！如今，机器已经能够在理解、识别图像中的特征和对象等领域实现99％级别的准确率。生活中，我们每天都会运用到这一点，比如，智能手机拍照的时候能够识别脸部、在类似于谷歌搜图中搜索特定照片、从条形码扫描文本或扫描书籍等。造就机器能够获得在这些视觉方面取得优异性能可能是源于一种特定类型的神经网络——卷积神经网络（CNN）。如果你是一个深度学习爱好者，你可能早已听说过这种神经网络，并且可能已经使用一些深度学习框架比如caffe、TensorFlow、pytorch实现了一些图像分类器。然而，这仍然存在一个问题：数据是如何在人工神经网络传送以及计算机是如何从中学习的。为了从头开始获得清晰的视角，本文将通过对每一层进行可视化以深入理解卷积神经网络。卷积神经网络在学习卷积神经网络之前，首先要了解神经网络的工作原理。神经网络是模仿人类大脑来解决复杂问题并在给定数据中找到模式的一种方法。在过去几年中，这些神经网络算法已经超越了许多传统的机器学习和计算机视觉算法。“神经网络”是由几层或多层组成，不同层中具有多个神经元。每个神经网络都有一个输入和输出层，根据问题的复杂性增加隐藏层的个数。一旦将数据送入网络中，神经元就会学习并进行模式识别。一旦神经网络模型被训练好后，模型就能够预测测试数据。另一方面，CNN是一种特殊类型的神经网络，它在图像领域中表现得非常好。该网络是由YanLeCunn在1998年提出的，被应用于数字手写体识别任务中。其它应用领域包括语音识别、图像分割和文本处理等。在CNN被发明之前，多层感知机（MLP）被用于构建图像分类器。图像分类任务是指从多波段（彩色、黑白）光栅图像中提取信息类的任务。MLP需要更多的时间和空间来查找图片中的信息，因为每个输入元素都与下一层中的每个神经元连接。而CNN通过使用称为局部连接的概念避免这些，将每个神经元连接到输入矩阵的局部区域。这通过允许网络的不同部分专门处理诸如纹理或重复模式的高级特征来最小化参数的数量。下面通过比较说明上述这一点。比较MLP和CNN因为输入图像的大小为28x28=784（MNIST数据集），MLP的输入层神经元总数将为784。网络预测给定输入图像中的数字，输出数字范围是0-9。在输出层，一般返回的是类别分数，比如说给定输入是数字“3”的图像，那么在输出层中，相应的神经元“3”与其它神经元相比具有更高的类别分数。这里又会出现一个问题，模型需要包含多少个隐藏层，每层应该包含多少神经元？这些都是需要人为设置的，下面是一个构建MLP模型的例子：Num_classes = 10Model = Sequntial()Model.add(Dense(512, activation=’relu’, input_shape=(784, )))Model.add(Dropout(0.2))Model.add(Dense(512, activation=’relu’))Model.add(Dropout(0.2))Model.add(Dense(num_classes, activation=’softmax’))上面的代码片段是使用Keras框架实现（暂时忽略语法错误），该代码表明第一个隐藏层中有512个神经元，连接到维度为784的输入层。隐藏层后面加一个dropout层，丢弃比例设置为0.2，该操作在一定程度上克服过拟合的问题。之后再次添加第二个隐藏层，也具有512谷歌神经元，然后再添加一个dropout层。最后，使用包含10个类的输出层完成模型构建。其输出的向量中具有最大值的该类将是模型的预测结果。这种多层感知器的一个缺点是层与层之间完全连接，这导致模型需要花费更多的训练时间和参数空间。并且，MLP只接受向量作为输入。卷积使用稀疏连接的层，并且其输入可以是矩阵，优于MLP。输入特征连接到局部编码节点。在MLP中，每个节点都有能力影响整个网络。而CNN将图像分解为区域（像素的小局部区域），每个隐藏节点与输出层相关，输出层将接收的数据进行组合以查找相应的模式。计算机如何查看输入的图像？看着图片并解释其含义，这对于人类来说很简单的一件事情。我们生活在世界上，我们使用自己的主要感觉器官（即眼睛）拍摄环境快照，然后将其传递到视网膜。这一切看起来都很有趣。现在让我们想象一台计算机也在做同样的事情。在计算机中，使用一组位于0到255范围内的像素值来解释图像。计算机查看这些像素值并理解它们。乍一看，它并不知道图像中有什么物体，也不知道其颜色。它只能识别出像素值，图像对于计算机来说就相当于一组像素值。之后，通过分析像素值，它会慢慢了解图像是灰度图还是彩色图。灰度图只有一个通道，因为每个像素代表一种颜色的强度。0表示黑色，255表示白色，二者之间的值表明其它的不同等级的灰灰色。彩色图像有三个通道，红色、绿色和蓝色，它们分别代表3种颜色（三维矩阵）的强度，当三者的值同时变化时，它会产生大量颜色，类似于一个调色板。之后，计算机识别图像中物体的曲线和轮廓。。下面使用PyTorch加载数据集并在图像上应用过滤器：# Load the librariesimport torchimport numpy as npfrom torchvision import datasetsimport torchvision.transforms as transforms# Set the parametersnum_workers = 0batch_size = 20# Converting the Images to tensors using Transformstransform = transforms.ToTensor()train_data = datasets.MNIST(root=‘data’, train=True, download=True, transform=transform)test_data = datasets.MNIST(root=‘data’, train=False, download=True, transform=transform)# Loading the Datatrain_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, num_workers=num_workers)test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, num_workers=num_workers)import matplotlib.pyplot as plt%matplotlib inlinedataiter = iter(train_loader)images, labels = dataiter.next()images = images.numpy()# Peeking into datasetfig = plt.figure(figsize=(25, 4))for image in np.arange(20): ax = fig.add_subplot(2, 20/2, image+1, xticks=[], yticks=[]) ax.imshow(np.squeeze(images[image]), cmap=‘gray’) ax.set_title(str(labels[image].item()))下面看看如何将单个图像输入神经网络中：img = np.squeeze(images[7])fig = plt.figure(figsize = (12,12)) ax = fig.add_subplot(111)ax.imshow(img, cmap=‘gray’)width, height = img.shapethresh = img.max()/2.5for x in range(width): for y in range(height): val = round(img[x][y],2) if img[x][y] !=0 else 0 ax.annotate(str(val), xy=(y,x), color=‘white’ if img[x][y]<thresh else ‘black’)上述代码将数字'3’图像分解为像素。在一组手写数字中，随机选择“3”。并且将实际像素值（0-255 ）标准化，并将它们限制在0到1的范围内。归一化的操作能够加快模型训练收敛速度。构建过滤器过滤器，顾名思义，就是过滤信息。在使用CNN处理图像时，过滤像素信息。为什么需要过滤呢，计算机应该经历理解图像的学习过程，这与孩子学习过程非常相似，但学习时间会少的多。简而言之，它通过从头学习，然后从输入层传到输出层。因此，网络必须首先知道图像中的所有原始部分，即边缘、轮廓和其它低级特征。检测到这些低级特征之后，传递给后面更深的隐藏层，提取更高级、更抽象的特征。过滤器提供了一种提取用户需要的信息的方式，而不是盲目地传递数据，因为计算机不会理解图像的结构。在初始情况下，可以通过考虑特定过滤器来提取低级特征，这里的滤波器也是一组像素值，类似于图像。可以理解为连接卷积神经网络中的权重。这些权重或滤波器与输入相乘以得到中间图像，描绘了计算机对图像的部分理解。之后，这些中间层输出将与多个过滤器相乘以扩展其视图。然后提取到一些抽象的信息，比如人脸等。就“过滤”而言，我们有很多类型的过滤器。比如模糊滤镜、锐化滤镜、变亮、变暗、边缘检测等滤镜。下面用一些代码片段来理解过滤器的特征：Import matplotlib.pyplot as pltImport matplotib.image as mpimgImport cv2Import numpy as npImage = mpimg.imread(‘dog.jpg’)Plt.imshow(image)# 转换为灰度图gray = cv2.cvtColor(image, cv2.COLOR_RB2GRAY)# 定义sobel过滤器sobel = np.array([-1, -2, -1],[0, 0, 0],[1, 2, 1]))# 应用sobel过滤器Filtered_image = cv2.filter2D(gray, -1, sobel_y)# 画图Plt.imshow(filtered_image, cmp=’gray’)以上是应用sobel边缘检测滤镜后图像的样子， 可以看到检测出轮廓信息。完整的CNN结构到目前为止，已经看到了如何使用滤镜从图像中提取特征。现在要完成整个卷积神经网络，cnn使用的层是：1.卷积层（Convolutional layer）2.池层(Pooling layer)3.全连接层(fully connected layer)典型的cnn网络结构是由上述三类层构成：下面让我们看看每个图层起到的的作用：* 卷积层（CONV）——使用过滤器执行卷积操作。因为它扫描输入图像的尺寸。它的超参数包括滤波器大小，可以是2x2、3x3、4x4、5x5（或其它）和步长S。结果输出O称为特征映射或激活映射，具有使用输入层计算的所有特征和过滤器。下面描绘了应用卷积的工作过程：池化层（POOL）——用于特征的下采样，通常在卷积层之后应用。池化处理方式有多种类型，常见的是最大池化（max pooling）和平均池化（ave pooling），分别采用特征的最大值和平均值。下面描述了池化的工作过程： 全连接层（FC）——在展开的特征上进行操作，其中每个输入连接到所有的神经元，通常在网络末端用于将隐藏层连接到输出层，下图展示全连接层的工作过程：在PyTorch中可视化CNN在了解了CNN网络的全部构件后，现在让我们使用PyTorch框架实现CNN。步骤1：加载输入图像：import cv2import matplotlib.pyplot as plt%matplotlib inlineimg_path = ‘dog.jpg’bgr_img = cv2.imread(img_path)gray_img = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2GRAY)# Normalisegray_img = gray_img.astype(“float32”)/255plt.imshow(gray_img, cmap=‘gray’)plt.show()步骤2：可视化过滤器对过滤器进行可视化，以更好地了解将使用哪些过滤器：import numpy as npfilter_vals = np.array([ [-1, -1, 1, 1], [-1, -1, 1, 1], [-1, -1, 1, 1], [-1, -1, 1, 1]])print(‘Filter shape: ‘, filter_vals.shape)# Defining the Filtersfilter_1 = filter_valsfilter_2 = -filter_1filter_3 = filter_1.Tfilter_4 = -filter_3filters = np.array([filter_1, filter_2, filter_3, filter_4])# Check the Filtersfig = plt.figure(figsize=(10, 5))for i in range(4): ax = fig.add_subplot(1, 4, i+1, xticks=[], yticks=[]) ax.imshow(filters[i], cmap=‘gray’) ax.set_title(‘Filter %s’ % str(i+1)) width, height = filters[i].shape for x in range(width): for y in range(height): ax.annotate(str(filters[i][x][y]), xy=(y,x), color=‘white’ if filters[i][x][y]<0 else ‘black’)步骤3：定义CNN模型本文构建的CNN模型具有卷积层和最大池层，并且使用上述过滤器初始化权重：import torchimport torch.nn as nnimport torch.nn.functional as Fclass Net(nn.Module): def init(self, weight): super(Net, self).init() # initializes the weights of the convolutional layer to be the weights of the 4 defined filters k_height, k_width = weight.shape[2:] # assumes there are 4 grayscale filters self.conv = nn.Conv2d(1, 4, kernel_size=(k_height, k_width), bias=False) # initializes the weights of the convolutional layer self.conv.weight = torch.nn.Parameter(weight) # define a pooling layer self.pool = nn.MaxPool2d(2, 2) def forward(self, x): # calculates the output of a convolutional layer # pre- and post-activation conv_x = self.conv(x) activated_x = F.relu(conv_x) # applies pooling layer pooled_x = self.pool(activated_x) # returns all layers return conv_x, activated_x, pooled_x# instantiate the model and set the weightsweight = torch.from_numpy(filters).unsqueeze(1).type(torch.FloatTensor)model = Net(weight)# print out the layer in the networkprint(model)Net((conv): Conv2d(1, 4, kernel_size=(4, 4), stride=(1, 1), bias=False)(pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))步骤4：可视化过滤器快速浏览一下所使用的过滤器def viz_layer(layer, n_filters= 4): fig = plt.figure(figsize=(20, 20)) for i in range(n_filters): ax = fig.add_subplot(1, n_filters, i+1) ax.imshow(np.squeeze(layer[0,i].data.numpy()), cmap=‘gray’) ax.set_title(‘Output %s’ % str(i+1))fig = plt.figure(figsize=(12, 6))fig.subplots_adjust(left=0, right=1.5, bottom=0.8, top=1, hspace=0.05, wspace=0.05)for i in range(4): ax = fig.add_subplot(1, 4, i+1, xticks=[], yticks=[]) ax.imshow(filters[i], cmap=‘gray’) ax.set_title(‘Filter %s’ % str(i+1))gray_img_tensor = torch.from_numpy(gray_img).unsqueeze(0).unsqueeze(1)步骤5：每层过滤器的输出在卷积层和池化层输出的图像如下所示：卷积层：池化层：可以看到不同层结构得到的效果会有所差别，正是由于不同层提取到的特征不同，在输出层集合到的特征才能很好地抽象出图像信息。本文作者：【方向】阅读原文本文为云栖社区原创内容，未经允许不得转载。 ...

摘要： Flair是一个基于PyTorch构建的NLP开发包，它在解决命名实体识别（NER）、部分语音标注（PoS）、语义消歧和文本分类等NLP问题达到了当前的最高水准。它是一个建立在PyTorch之上的NLP框架。本文将介绍如何使用已有的和构建自定义的文本分类器。介绍文本分类是一种监督机器学习方法，用于将句子或文本文档归类为一个或多个已定义好的类别。它是一个被广泛应用的自然语言处理方法，在垃圾邮件过滤、情感分析、新闻稿件分类以及与许多其它业务相关的问题中发挥着重要作用。目前绝大多数最先进的方法都依赖于一种被称为文本嵌入的技术。它将文本转换成高维空间中的数值表示方式。它可以将文档、语句、单词、字符（取决于我们所嵌入的形式）表示为这个高维空间中的一个向量。Flair之所以对NLP来说是一个令人兴奋的消息，是因为Zalando Research最近发表的一篇论文《Contextual String Embeddings for Sequence Labelling（用于序列标注的上下文相关字符串的嵌入）》，其中涵盖了一种始终优于以前最先进方案的方法。该算法在Flair中得到了完整的支持和实现，可以用来构建文本分类器。1、准备安装Flair需要Python 3.6，如果你还没有，请点击这里查看安装向导。然后执行pip命令安装即可:pip install flair上面的命令将安装运行Flair所需的所有依赖包，当然也包括了PyTorch。2、使用一个预训练的分类模型最新的0.4版本包含了两个预训练的模型，还有一个基于IMDB数据集上训练的情感分析模型和“攻击性语言检测”模型（当前仅支持德语）。使用、下载和存储模型都被整合到了一个单一的方法中，这使得使用预训练模型的整个过程都非常简单。要使用情感分析模型，只需执行以下代码片段：fromflair.models import TextClassifierfrom flair.data import Sentenceclassifier = TextClassifier.load(’en-sentiment’)sentence = Sentence(‘Flair is pretty neat!’)classifier.predict(sentence)# print sentence with predicted labelsprint(‘Sentence above is: ‘, sentence.labels)当第一次运行时，Flair将下载情感分析模型，默认情况下将其存储到home目录下的.flair子目录中，这大概得需要几分钟。上面的代码首先加载必需的库，然后将情感分析模型加载到内存中（必要时先进行下载），接下来可以预测句子“Flair is pretty neat！”的情感数值，按0到1的区间赋值。最后命令的输出结果是：The sentence above is: [Positive (1.0)]就是这么简单！例如，现在你可以将上述代码合并在一个REST API中，并提供一个与Google的云自然语言API的情感分析类似的服务，当在有大量请求的生产环境中使用时，这种分析的成本将会非常的高。3、训练一个自定义文本分类器要训练一个自定义的文本分类器，我们首先需要一个标注过的数据集。Flair的分类数据集格式基于Facebook的FastText格式。格式要求在每行的开头定义一个或多个标签，以前缀__label__开头。格式如下:label<class_1><text>label<class_2><text>在本文中，我们将利用Kaggle的Spam Detection数据集通过Flair构建一个垃圾/非垃圾的分类器。这个数据集比较适合我们的学习任务，因为它足够小，并且仅包含5572行的数据，可以在一个CPU上只花几分钟就可以完成一个模型的训练。来自数据集中的标记为spam（垃圾邮件）或ham（非垃圾邮件）的SMS信息3.1 预处理-构建数据集我们首先从Kaggle上的这个链接下载数据集来获得spam.csv文件。然后，在与数据集相同的目录中，我们运行下面的预处理代码片段，该代码将执行一些预处理，并将数据集拆分为训练集、开发集和测试集三个部分。确保安装了Pandas。如果还没有，请先运行命令：pip install pandasimport pandas as pddata = pd.read_csv("./spam.csv", encoding=‘latin-1’).sample(frac=1).drop_duplicates()data = data[[‘v1’, ‘v2’]].rename(columns={“v1”:“label”, “v2”:“text”})data[’label’] = ‘label’ + data[’label’].astype(str)data.iloc[0:int(len(data)*0.8)].to_csv(’train.csv’, sep=’\t’, index = False, header = False)data.iloc[int(len(data)*0.8):int(len(data)*0.9)].to_csv(’test.csv’, sep=’\t’, index = False, header = False)data.iloc[int(len(data)*0.9):].to_csv(‘dev.csv’, sep=’\t’, index = False, header = False);上面的代码将从数据集中删除一些重复数据，并对其进行无序处理（随机化行），并按照80/10/10的比例将数据拆分为训练集、开发集和测试集。如果运行成功，你将会得到FastText格式的三个数据文件：train.csv、test.csv和dev.csv，它们可以与Flair一起使用。3.2 训练自定义文本分类模型请在生成数据集的目录中运行以下代码片段用以训练模型：fromflair.data_fetcher import NLPTaskDataFetcherfrom flair.embeddings import WordEmbeddings, FlairEmbeddings, DocumentLSTMEmbeddingsfrom flair.models import TextClassifierfrom flair.trainers import ModelTrainerfrom pathlib import Pathcorpus = NLPTaskDataFetcher.load_classification_corpus(Path(’./’), test_file=‘test.csv’, dev_file=‘dev.csv’, train_file=‘train.csv’)word_embeddings = [WordEmbeddings(‘glove’), FlairEmbeddings(’news-forward-fast’), FlairEmbeddings(’news-backward-fast’)]document_embeddings = DocumentLSTMEmbeddings(word_embeddings, hidden_size=512, reproject_words=True, reproject_words_dimension=256)classifier = TextClassifier(document_embeddings, label_dictionary=corpus.make_label_dictionary(), multi_label=False)trainer = ModelTrainer(classifier, corpus)trainer.train(’./’, max_epochs=10)第一次运行上述代码时，Flair将会自动下载需要的所有嵌入模型，这可能需要几分钟，然后接下来的整个培训过程还需要大约5分钟。程序首先将所需的库和数据集加载到一个corpus对象中。接下来，我们创建一个嵌入列表，包含两个Flair上下文的字符串嵌入和一个GloVe单词嵌入。然后将此列表作为文档嵌入对象的输入。堆叠和文档嵌入是Flair中最有趣的概念之一，提供了将不同的嵌入整合在一起的方法。你可以同时使用传统的单词嵌入（如GloVe, word2vec, ELMo）和Flair上下文的字符串嵌入。在上面的例子中，我们使用了一种基于LSTM（Long Short-Term Memory，长短期记忆网络）的方法，将单词和上下文的字符串嵌入结合起来以生成文档嵌入。想要了解更多，请点击这里。最后，上述代码进行模型训练并生成了final-model.pt和best-model.pt两个文件，它们表示我们存储的训练模型。3.3 用训练过的模型进行预测我们现在可以从同一目录通过运行以下代码，使用导出的模型来生成预测结果：fromflair.models import TextClassifierfrom flair.data import Sentenceclassifier = TextClassifier.load_from_file(’./best-model.pt’)sentence = Sentence(‘Hi. Yes mum, I will…’)classifier.predict(sentence)print(sentence.labels)这段代码会输出“[ham（1.0）]”，这意味着该模型100%确定我们的示例消息不是垃圾邮件。与其它框架相比表现如何？与Facebook的FastText甚至谷歌的AutoML自然语言平台不同，使用Flair进行文本分类仍然是一项底层的工作。我们可以通过设置诸如学习率、批量大小、退火因子（anneal factor）、损失函数、优化选择等参数来完全控制文本嵌入和训练的方式…为了获得最佳表现，需要调整这些超参数。Flair为我们提供了一个有名的超参数调优库Hyperopt的封装器，我们可以使用它来对超参数进行调优以获得最佳的性能。在本文中，为了简单起见，我们使用了默认的超参数。在大多数默认参数下，我们的Flair模型在10个训练周期后获得了0.973的f1-score。为了进行对比，我们使用FastText和AutoML自然语言平台训练了一个文本分类模型。首先我们使用默认参数运行FastText，并获得了0.883的f1-score，这意味着模型在很大程度上优于FastText。然而，FastText只需要几秒钟的训练时间，而我们训练的Flair模型则需要5分钟。我们将结果与在谷歌的AutoML自然语言平台上获得的结果进行了比较。平台首先需要20分钟来解析数据集。之后，我们开始了训练过程，这几乎花了3个小时完成，但却获得了99.211的f1-score——这比我们自己训练的模型稍微好一点。本文作者：【方向】阅读原文本文为云栖社区原创内容，未经允许不得转载。 ...

摘要： 学习完了如何加载预训练神经网络，下面就让我们来看看如何训练分类器吧！在第一部分中，我们知道了为什么以及如何加载预先训练好的神经网络，我们可以用自己的分类器代替已有神经网络的分类器。那么，在这篇文章中，我们将学习如何训练分类器。训练分类器首先，我们需要为分类器提供待分类的图像。本文使用ImageFolder加载图像，预训练神经网络的输入有特定的格式，因此，我们需要用一些变换来调整图像的大小，即在将图像输入到神经网络之前，对其进行裁剪和标准化处理。具体来说，将图像大小调整为224*224，并对图像进行标准化处理，即均值为 [0.485,0.456,0.406]，标准差为[0.229,0.224,0.225]，颜色管道的均值设为0，标准差缩放为1。然后，使用DataLoader批量传递图像，由于有三个数据集：训练数据集、验证数据集和测试数据集，因此需要为每个数据集创建一个加载器。一切准备就绪后，就可以训练分类器了。在这里，最重要的挑战就是——正确率（accuracy）。让模型识别一个已经知道的图像，这不算啥事，但是我们现在的要求是：能够概括、确定以前从未见过的图像中花的类型。在实现这一目标过程中，我们一定要避免过拟合，即“分析的结果与特定数据集的联系过于紧密或完全对应，因此可能无法对其他数据集进行可靠的预测或分析”。隐藏层实现适当拟合的方法有很多种，其中一种很简单的方法就是：隐藏层。我们很容易陷入这样一种误区：拥有更多或更大的隐藏层，能够提高分类器的正确率，但事实并非如此。增加隐藏层的数量或大小以后，我们的分类器就需要考虑更多不必要的参数。举个例子来说，将噪音看做是花朵的一部分，这会导致过拟合，也会降低精度，不仅如此，分类器还需要更长的时间来训练和预测。因此，我建议你从数量较少的隐藏层开始，然后根据需要增加隐藏层的数量或大小，而不是一开始就使用特别多或特别大的隐藏层。在第一部分介绍的《AI Programming with Python Nanodegree》课程中的花卉分类器项目中，我只需要一个小的隐藏层，在第一个完整训练周期内，就得到了70%以上的正确率。数据增强我们有很多图像可供模型训练，这非常不错。如果拥有更多的图像，数据增强就可以发挥作用了。每个图像在每个训练周期都会作为神经网络的输入，对神经网络训练一次。在这之前，我们可以对输入图像做一些随机变化，比如旋转、平移或缩放。这样，在每个训练周期内，输入图像都会有差异。增加训练数据的种类有利于减少过拟合，同样也提高了分类器的概括能力，从而提高模型分类的整体准确度。Shuffle在训练分类器时，我们需要提供一系列随机的图像，以免引入任何误差。举个例子来说，我们刚开始训练分类器时，我们使用“牵牛花”图像对模型进行训练，这样一来，分类器在后续训练过程中将会偏向“牵牛花”，因为它只知道“牵牛花”。因此，在我们使用其他类型的花进行训练时，分类器最初的偏好也将持续一段时间。为了避免这一现象，我们就需要在数据加载器中使用不同的图像，这很简单，只需要在加载器中添加shuffle=true，代码如下：trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)Dropout有的时候，分类器中的节点可能会导致其他节点不能进行适当的训练，此外，节点可能会产生共同依赖，这就会导致过拟合。Dropout技术通过在每个训练步骤中使一些节点处于不活跃状态，来避免这一问题。这样一来，在每个训练阶段都使用不同的节点子集，从而减少过拟合。除了过拟合，我们一定要记住，学习率（ learning rate ）是最关键的超参数。如果学习率过大，模型的误差永远都不会降到最小；如果学习率过小，分类器将会训练的特别慢，因此，学习率不能过大也不能过小。一般来说，学习率可以是0.01,0.001,0.0001……，依此类推。最后，在最后一层选择正确的激活函数会对模型的正确率会产生特别大的影响。举个例子来说，如果我们使用 negative log likelihood loss（NLLLoss），那么，在最后一层中，建议使用LogSoftmax激活函数。结论理解模型的训练过程，将有助于创建能够概括的模型，在预测新图像类型时的准确度更高。在本文中，我们讨论了过拟合将会如何降低模型的概括能力，并学习了降低过拟合的方法。另外，我们也强调了学习率的重要性及其常用值。最后，我们知道，为最后一层选择正确的激活函数非常关键。现在，我们已经知道应该如何训练分类器，那么，我们就可以用它来预测以前从未见过的花型了！本文作者：【方向】阅读原文本文为云栖社区原创内容，未经允许不得转载。

摘要： 本文将为你介绍为何要重用神经网络？哪部分可以重用，哪部分不可以重用。了解完这些基础概念，你就可以自行创建一个图像分类器了。经过了几个月的学习和实践，我完成了优达学城网站上《Python Programming with Python Nanodegree》课程的学习，该课程的终极项目就是使用Pytorch为102种不同类型的花创建一个图像分类器。在完成这个项目的过程中，我和其他学员一样，都碰到了各种问题和挑战，因此写下了这篇文章。希望你读完这篇文章以后，会对你的机器学习有所裨益。本文介绍了如何实现图像分类的基础概念，即理解图像内容的算法。本文并不会详细分步说明构建模型的具体步骤，而是从宏观上介绍整个过程，如果你正在学习机器学习或人工智能，相信这篇文章将会对你很有帮助。在第一部分中，我们将介绍加载预训练的神经网络，为什么要“重用”网络（即使用预训练神经网络），指明哪些部分可以重用，哪些部分不可以重用，以及如何自定义预训练网络。加载一个预训练网络“重用”是一个非常合理的策略，特别是当某些工具是大家都认可为标准的时候，“重用”更显得尤为重要。在这个例子中，我们的出发点是torchvision提供的一个模型框架。现在，我们要做的是加载一个预先训练好的网络，并用自己的网络替换它的分类器，然后，我们就可以训练自己的分类器了。虽然这个想法很合理，但是也比较麻烦，因为加载一个预先训练好的网络，并不会节省我们训练分类器的工作量。所以，使用预训练网络到底有什么好处呢？当我们人类在看图像的时候，我们会识别线条和形状，鉴于此，我们才可以将图像内容与之前看到的内容联系起来。现在，我们希望分类器也能做到这点，但是，图像并不是一个简单的数据，而是由数千个独立的像素组成，每个像素又由3个不同的值组合起来，形成颜色，即红色、绿色和蓝色。 如果我们希望分类器能够处理这些数据，我们要做的就是将每个待处理图像所包含的信息，以分类器可以理解的格式传给分类器，这就是预训练网络发挥作用的地方。这些预训练网络主要由一组特征检测器和分类器组成，其中，特征检测器被训练成可以从每个图像中提取信息，分类器被训练成理解特征层提供的输入。在这里，特征检测器已经在ImageNet中接受过训练，并且性能良好，我们希望这点能够继续保持。在训练分类器时，为了防止特征层被篡改，我们得对特征层进行“冻结”，下面这些代码可以很轻松的解决这一问题：for param in model.parameters(): param.requires_grad = False那么，问题又来了，既然我们可以“重用”特征检测器，我们为什么不能“重用”分类器？要回答这个问题，我们先来看看VGG16架构的默认分类器：(classifier): Sequential( (0): Linear(in_features=25088, out_features=4096, bias=True) (1): ReLU(inplace) (2): Dropout(p=0.5) (3): Linear(in_features=4096, out_features=4096, bias=True) (4): ReLU(inplace) (5): Dropout(p=0.5) (6): Linear(in_features=4096, out_features=1000, bias=True))首先，我们没办法保证这些代码能够起作用，在我们特定的环境中，这些默认层、元素、激活函数以及Dropout值并不一定是最佳的。尤其是最后一层的输出是1000个元素，这就容易理解了。在我们的例子中，我们要对102种不同类型的花进行分类，因此，我们的分类器输出必须是102，而不是1000。从上面VGG16架构的默认分类器中，我们还可以注意到，分类器的输入层有25088个元素，这是特定预训练模型中特征检测器的输出大小，因此，我们的分类器大小也必须要与要特征层的输出相匹配。结论从上面的分析，本文能够得到以下结论：1.预先训练好的网络非常有用。使用预训练模型，可以让我们更加专注于我们自己用例的具体细节，还可以重用众所周知的工具，对用例中的图像进行预处理。2.分类器的输出大小必须与我们希望识别的图像数量相同。3.特征层的输出和自定义分类器的输入大小必须相匹配。在下一篇文章中，我们将深入探讨，在训练分类器过程中，如何避免一些常见的陷阱，并学习如何调整超参数，来提高模型的准确性。本文作者：【方向】阅读原文本文为云栖社区原创内容，未经允许不得转载。