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特征。