精华内容
下载资源
问答
  • Torch安装与使用指南

    2019-09-13 08:53:54
    无CUDA的Torch7安装 (1)安装Luarocks sudo apt-get install luarocks (2)安装Torch git clone https://github.com/torch/distro.git ~/torch --recursive cd ~/torch bash install-deps ./...

    无CUDA的Torch7安装
    (1)安装Luarocks

    sudo apt-get install luarocks
    

    (2)安装Torch

    git clone https://github.com/torch/distro.git ~/torch --recursive
    
    cd ~/torch
    
    bash install-deps
    
    ./install.sh
    

    说明: /torch应该就是终端当前所在的文件夹(默认时为/home/XXX/,加了/torch后就变成了/home/XXX/torch)
    若提示cmake: 未找到命令则还需要安装cmake
    获cmake源码包,这里我先新建一个文件夹来存放cmake

    mkdir app
    
    cd ./app
    
    wget https://cmake.org/files/v3.3/cmake-3.3.2.tar.gz
    

    解压源码包

    tar xzvf cmake-3.3.2.tar.gz
    

    可能会提示需要安装yum

    sudo apt install yum
    

    安装即将结束的时候会提示:
    Do you want to automatically prepend the Torch install location
    to PHTH and LD_LIBRARY_PATH in your/home/gsta/.bashre?(yes/no)
    输入yes,最后使刚才设置的环境变量生效,Torch就安装成功了。
    可以输入

    source ~/.bashrc
    
    th
    

    出现图像证明安装成功
    在这里插入图片描述

    CUDA的Torch7安装
    在无CUDA的Torch7安装基础上,安装CUDA之后,可使用NVIDIA CUDA加速版本的Torch7,安装步骤如下。
    (1)下载NVIDIA CUDA适配的代码

    git clone https://github.com/torch/cutorch.git
    

    (2)安装编译依赖的库

    sudo apt install nvidia-cuda-toolkit
    

    (3)编译代码

    cd cutorch
    
    mkdir build
    
    cd build
    
    cmake ..
    
    make
    

    安装完成后,在命令行输入th,出现torch字样图形即为安装成功。

    用Torch框架画一幅油画
    下面是一个可以让电脑模仿任何画家的风格作画的项目。
    (1)安装loadcaffe

    sudo apt-get install lidprotobuf-dev protobuf-compiler luarocks install loadcaffe
    

    (2)下载neural-style代码

    cd ~/
    
    git clone https://github.com/jcjohnson/neural-style
    
    cd neural-style
    

    (3)下载模块

    sh models/download_models.sh
    

    下载完成后,在models文件下有VGG_ILSVRC_19_layers.caffemodel和vgg_normalised.caffemodel两个模型。
    (4)运行无CPU的代码

    th neural_style.lua -gpu -1 -print_iter 1
    

    上述命令中的“-gpu -1”表示无GPU运行
    (5)安装CUDA、cuDNN
    (6)安装cutorch、cunn、cuDNN

    luarocks install cutorch
    
    luarocks install cunn
    
    luarocks install cudnn
    

    检查安装状况:

    th -“require’cutorch’;require’cunn’;print(cutorch)

    (7)生成具有特定风格的图像

    th neural_style.lua -style_image style.jpg -content _image in.jpg -gpu -0
    

    命令解释:th neural_style.lua -style_image 风格图片 -content_image想处理的图片 -gpu -0。

    展开全文
  • PyTorch是一个深度学习框架和一个科学计算包,这是PyTorch核心团队对PyTorch的描述,PyTorch的科学计算方面主要是PyTorch...举个例子,PyTorch的torch.Tensor对象就是由Numpy的ndarray对象创建来的,两者之间的转...

    本文是对 Neural Network Programming - Deep Learning with PyTorch 系列博客的翻译与整理,英语基础比较好的同学推荐阅读原汁原味的博客。

    PyTorch是一个深度学习框架和一个科学计算包,这是PyTorch核心团队对PyTorch的描述,PyTorch的科学计算方面主要是PyTorch张量(tensor)库和相关张量运算的结果。A tensor is an n-dimensional array (ndarray)。PyTorch的torch.Tensor对象就是由Numpy的ndarray对象创建来的,两者之间的转换十分高效。PyTorch中内置了对GPU的支持,如果我们在系统上安装了GPU,那么使用PyTorch将张量在GPU之间来回移动是非常容易的一件事情。

    1. PyTorch简介

      PyTorch的首次发布是在2016年10月,在PyTorch创建之前,还有一个叫做Torch(火炬)的框架。Torch是一个已经存在了很长时间的机器学习框架,它基于Lua编程语言。PyTorch和这个Lua版本(称为Torch)之间的联系是存在的,因为许多维护Lua版本的开发人员也参与了PyTorch的开发工作。你可能听说过PyTorch是由Facebook创建和维护的,这是因为PyTorch在创建时,Soumith Chintala(创始人)在Facebook AI Research工作。

      下表列出了PyTorch包及其相应的说明。这些是我们在本系列中构建神经网络时将学习和使用的主要PyTorch组件。

    PackageDescription
    torch顶层的PyTorch包和tensor库
    torch.nn一个子包,用于构建神经网络的模块和可扩展类
    torch.autograd一个子包,支持PyTorch中所有微分张量运算
    torch.nn.functional一种函数接口,包含构建神经网络的操作,如损失函数、激活函数和卷积操作。
    torch.optim一个子包,包含标准优化操作,如SGD和Adam
    torch.utils一个子包,包含数据集和数据加载器等实用工具类,使数据预处理更容易
    torchvision提供对流行数据集、模型体系结构和图像转换的访问的包

      为了优化神经网络,我们需要计算导数,为了进行计算,深度学习框架使用所谓的计算图(computational graphs),计算图用于描述神经网络内部张量上发生的函数运算操作。

      PyTorch使用一个称为动态计算图的计算图,这意味着计算图是在创建操作时动态生成的,这与在实际操作发生之前就已完全确定的静态图形成对比。正因为如此,许多深度学习领域的前沿研究课题都需要动态图,或者从动态图中获益良多。

    2. GPU相关介绍

      GPU是一种擅长处理特定计算(specialized computations)的处理器。这与中央处理器(CPU)形成对比,中央处理器是一种善于处理一般计算(general computations)的处理器。CPU是在我们的电子设备上支持大多数典型计算的处理器。

      GPU的计算速度可能比CPU快得多。 然而,这并非总是如此。 GPU相对于CPU的速度取决于所执行的计算类型。最适合GPU的计算类型是可以并行完成的计算。

      并行计算(paraller computing)是一种将特定计算分解成可以同时进行的独立的较小计算的计算方式,然后重新组合或同步计算结果,以形成原来较大计算的结果。

      一个较大的任务可以分解成的任务数量取决于特定硬件上包含的内核数量。核心是在给定处理器中实际执行计算的单元,CPU通常有4个、8个或16个核心,而GPU可能有数千个。

      有了这些工作知识,我们可以得出结论,并行计算是使用GPU完成的,我们还可以得出结论,最适合使用GPU解决的任务是可以并行完成的任务。如果计算可以并行完成,我们可以使用并行编程方法和GPU加速计算。

      现在我们把目光转移到神经网络上,看看为什么GPU在深度学习中被大量使用。 我们刚刚看到GPU非常适合并行计算,而关于GPU的事实就是深度学习使用GPU的原因。

       Neural networks are embarrassingly parallel.指的是一个任务分解为几个子任务之后,在不同处理器上执行该子任务,而这些子任务之间不会相互依赖,也就说明该任务十分适合于并行计算,也被称为embarrassingly parallel.

      我们用神经网络所做的许多计算可以很容易地分解成更小的计算,这样一组更小的计算就不会相互依赖了。卷积操作就是这样一个例子。

    • 蓝色区域(底部): Input channel
    • 阴影区域(底部): Filter
    • 绿色区域(顶部): Output channel

      对于蓝色输入通道上的每个位置,3 x 3过滤器都会进行计算,将蓝色输入通道的阴影部分映射到绿色输出通道的相应阴影部分。在动画中,这些计算一个接一个地依次进行。但是,每个计算都是独立于其他计算的,这意味着任何计算都不依赖于任何其他计算的结果。因此,所有这些独立的计算都可以在GPU上并行进行,从而产生整个输出通道,加速我们的卷积过程。

    3. CUDA相关介绍

      Nvidia是一家设计GPU的技术公司,他们创建了CUDA作为一个软件平台,与GPU硬件适配,使开发人员更容易使用Nvidia GPU的并行处理能力来构建加速计算的软件。Nvidia GPU是支持并行计算的硬件,而CUDA是为开发人员提供API的软件层。

      开发人员通过下载CUDA工具包来使用CUDA,伴随工具包一起的是专门的库,如 cuDNN, CUDA Deep Neural Network library.

      在PyTorch中利用CUDA非常简单。如果我们希望在GPU上执行特定的计算,我们可以通过在数据结构(tensors)上调用cuda()来指示PyTorch这样做。

      假设我们有以下代码:

    > t = torch.tensor([1,2,3])
    > t
    tensor([1, 2, 3])
    

      默认情况下,以这种方式创建的tensor对象在CPU上。因此,我们使用这个张量对象所做的任何操作都将在CPU上执行。

      现在,要把张量移到GPU上,我们只需要写:

    > t = t.cuda()
    > t
    tensor([1, 2, 3], device='cuda:0')
    

      由于可以在CPU或GPU上有选择地进行计算,因此PyTorch的用途非常广泛。

      GPU是不是总是比CPU更好呢?答案是否定的。

      GPU只对特定的(专门的)任务更快。它也会遇到某些瓶颈,例如,将数据从CPU移动到GPU的成本很高(耗时),因此在这种情况下,如果计算任务本身就很简单,还把它转移到GPU上进行计算,那么总体性能可能会降低。

      把一些相对较小的计算任务转移到GPU上不会使我们的速度大大加快,而且可能确实会减慢我们的速度。GPU对于可以分解为许多较小任务的任务非常有效,如果计算任务已经很小,那么将任务移到GPU上就不会有太多收获。

    4. 张量定义

      神经网络中的输入、输出和变换都是用tensor表示的,在神经网络编程中大量使用了tensor

      张量的概念是其他更具体概念的数学概括,让我们看看张量的一些具体实例:

    • number
    • scalar
    • array
    • vector
    • 2d-array
    • matrix

      我们来把上面的张量实例分成两组:

    • number, array, 2d-array
    • scalar, vector, matrix

      第一组中的三个术语(数字、数组、二维数组)是计算机科学中常用的术语,而第二组(标量、矢量、矩阵)是数学中常用的术语。

      我们经常看到这种情况,不同的研究领域对同一概念使用不同的词。在深度学习中,我们通常把这些都称为tensor

    Indexes requriedComputer scienceMathematics
    0numberscala
    1arrayvector
    22d-arraymatrix
    nnd-arraynd-tensor

    5. 张量的秩、轴和形状

      在深度学习中,秩、轴和形状是我们最关心的tensor属性,这些概念建立在一个又一个的基础上,从秩开始,然后是轴,再到形状,请注意这三者之间的关系。

      我们在这里引入rank这个词,是因为它在深度学习中经常被用到,它指的是给定张量中的维数,一个张量的秩告诉我们需要多少索引来引用张量中的某一个特定元素。

      如果我们有一个张量,想要表示某一个特定的维度,那么在深度学习中使用轴(Axis)这个词。

      每个轴的长度告诉我们每个轴上有多少索引可用,假设我们有一个张量 t,我们知道第一个轴的长度为3,而第二个轴的长度为4。

      我们可以索引第一个轴的每一个元素像这样:

    t[0]
    t[1]
    t[2]
    

      由于第二轴的长度为4,所以我们可以沿着第二轴标出4个位置。这对于第一轴的每个索引都是成立的,所以我们有:

    t[0][0]
    t[1][0]
    t[2][0]
    
    t[0][1]
    t[1][1]
    t[2][1]
    
    t[0][2]
    t[1][2]
    t[2][2]
    
    t[0][3]
    t[1][3]
    t[2][3]
    

      张量的形状是由每个轴的长度决定的,所以如果我们知道给定张量的形状,那么我们知道每个轴的长度,这告诉我们每个轴有多少个索引可用。

      我们结合一个实例来看看形状(shape)是如何计算的。

    > a = torch.tensor([[[[1]],[[2]],[[3]]]])
    > print(a)
    tensor([[[[1]],
    
             [[2]],
    
             [[3]]]])
    

      如何来计算它的形状呢,首先我们数一下中括号的个数,得知这是一个四维张量,然后由外而内,去掉最外层的中括号之后,得到 tensor([[[1]], [[2]], [[3]]]),此时只有一个最外层的中括号,那我们的shape变为 ( 1 ,    ,    , ) (1, \;,\; ,) (1,,,);同理,我们继续去除最外层的中括号,得到 tensor([[1]], [[2]], [[3]]),此时有三个最外层的中括号,那我们的shape则变为 ( 1 , 3 ,    , ) (1, 3,\; ,) (1,3,,),因为每一个维度的形状是相同的,于是我们继续来只需要看其中一个维度即可,即 tensor([[1]]);去除最外层的中括号,得到 tensor([1]),此时只有一个最外层的中括号,shape变为 ( 1 , 3 , 1 , ) (1, 3,1 ,) (1,3,1,);最后再去除一个中括号,得到 tensor(1),shape变为 ( 1 , 3 , 1 , 1 ) (1, 3,1 ,1) (1,3,1,1),以上就是得到张量形状的全部过程。

    > print(a.shape)
    torch.Size([1, 3, 1, 1])
    

    6. CNN中的张量

      CNN输入的形状,通常有4个维度,也就是说我们有一个秩为4的四阶张量,张量中的每一个索引对应着一个轴,每一个轴都代表着输入数据的某种实际特征,我们从右到左,来理解CNN输入的张量中,每个维度的含义。

      原始图像数据以像素的形式出现,用数字表示,并使用高度和宽度两个维度进行布局,所以我们需要 width 和 height 两个轴。

      下一个轴表示图像的颜色通道数,灰度图的通道数为1,RGB图的通道数为3,这种颜色通道的解释仅适用于输入张量,后续 feature map 中的通道都不是代表颜色。

      也就是说,张量中的最后三个轴,表示着一个完整的图像数据。在神经网络中,我们通常处理成批的样本,而不是单个样本,所以最左边的轴的长度,告诉我们一批中有多少个样本。

      假设给定张量的形状为 [3,1,28,28] ,那么我们可以确定,一个批次中有三幅图像,每张图像的颜色通道数为3,宽和高都是28。 [Batch, Channels, Height, Width]

      我们接下来看看张量被卷积层变换后,颜色通道轴的解释是如何变化的。

      假设我们有一个 tensor 的形状为 [1,1,28,28],当它经过一个卷积层之后,张量的宽和高,以及通道数量都会发生改变,输出的通道数即对应着卷积层中卷积核的个数。

      输出的通道不再解释为颜色通道,而是 feature map 的修改通道(modified channels),使用 feature 一词是因为卷积层的输出,代表图像中的特定特征,例如边缘,这些映射随着网络在训练过程中的学习而出现,并且随着我们深入网络而变得更加复杂。

    7. torch.Tensor类

      我们可以用下面的方式,构建一个 torch.Tensor 类的实例:

    > t = torch.Tensor()
    > type(t)
    torch.Tensor
    

      每一个 torch.Tensor 对象都有3个属性:

    > print(t.dtype)
    > print(t.device)
    > print(t.layout)
    torch.float32
    cpu
    torch.strided
    

      我们来详细看一下dtype有哪些属性:

    Data typedtypeCPU tensorGPU tensor
    32-bit floating pointtorch.float32torch.FloatTensortorch.cuda.FloatTensor
    64-bit floating pointtorch.float64torch.DoubleTensortorch.cuda.DoubleTensor
    16-bit floating pointtorch.float16torch.HalfTensortorch.cuda.HalfTensor
    8-bit integer (unsigned)torch.uint8torch.ByteTensortorch.cuda.ByteTensor
    8-bit integer (signed)torch.int8torch.CharTensortorch.cuda.CharTensor
    16-bit integer (signed)torch.int16torch.ShortTensortorch.cuda.ShortTensor
    32-bit integer (signed)torch.int32torch.IntTensortorch.cuda.IntTensor
    64-bit integer (signed)torch.int64torch.LongTensortorch.cuda.LongTensor

      注意,每种类型有一个CPU和GPU版本。关于张量数据类型,需要记住的一点是,张量之间的张量运算必须发生在具有相同类型数据的张量之间

      device用来表示张量的数据是存储在 CPU 上还是 GPU 上。它决定来张量计算的位置在哪里。我们可以用 索引 的方式来指定设备的编号:

    > device = torch.device('cuda:0')
    > device
    device(type='cuda', index=0)
    

      使用多个设备时,需要记住的一点是张量之间的张量运算必须发生在同一设备上的张量之间

      layout属性用来指定张量在内存中是如何存储的。

      在 PyTorch 中,可以通过以下四种方式将一个 array-like 的对象转成 torch.Torch 的对象。

    torch.Tensor(data)
    torch.tensor(data)
    torch.as_tensor(data)
    torch.from_numpy(data)
    

      我们可以直接创建一个 Python list 类型的 data,不过 numpy.ndarray 是一个更加常见的选择,如下所示:

    > data = np.array([1,2,3])
    > type(data)
    numpy.ndarray
    

      然后再用上面的四种方式来创建一个 torch.Torch 的对象:

    > o1 = torch.Tensor(data)
    > o2 = torch.tensor(data)
    > o3 = torch.as_tensor(data)
    > o4 = torch.from_numpy(data)
    
    > print(o1)
    > print(o2)
    > print(o3)
    > print(o4)
    tensor([1., 2., 3.])
    tensor([1, 2, 3], dtype=torch.int32)
    tensor([1, 2, 3], dtype=torch.int32)
    tensor([1, 2, 3], dtype=torch.int32)
    

      除了第一个之外,其他的输出(o2、o3、o4)似乎都产生了相同的张量,第一个输出(o1)在数字后面有圆点,表示数字是浮点数,而后面三个选项的类型是int32。

    > type(2.)
    float
    > type(2)
    int
    

      当然,PyTorch 也内置了一些不需要通过数据转换,直接构成张量的方式。

    > print(torch.eye(2))
    tensor([
        [1., 0.],
        [0., 1.]
    ])
    
    > print(torch.zeros([2,2]))
    tensor([
        [0., 0.],
        [0., 0.]
    ])
    
    > print(torch.ones([2,2]))
    tensor([
        [1., 1.],
        [1., 1.]
    ])
    
    > print(torch.rand([2,2]))
    tensor([
        [0.0465, 0.4557],
        [0.6596, 0.0941]
    ])
    

    8. 创建Tensor的方法对比

      先来看看 torch.tensor()torch.Tensor() 这两种方法的区别:

    > data = np.array([1,2,3])
    > type(data)
    numpy.ndarray
    
    > o1 = torch.Tensor(data)
    > o2 = torch.tensor(data)
    
    > print(o1)
    > print(o2)
    
    tensor([1., 2., 3.])
    tensor([1, 2, 3], dtype=torch.int32)
    

      torch.Tensor() 是 torch.Tensor 类的构造函数,torch.tensor()是工厂函数,它构造 torch.Tensor 对象并将它们返回给调用方,这是一种创建对象的软件设计模式,另一个区别就是前者默认的数据类型是浮点型,而后者是整型。数据类型可以显示地指定,不指定的话,可以通过传入的数据类型来推断。四种构造方法中只有 torch.Tensor() 函数不可以显示指定dtype

    > torch.tensor(data, dtype=torch.float32)
    > torch.as_tensor(data, dtype=torch.float32)
    

      我们再来看看几种方法创建 tensor 时,对传入的 data 采取的是拷贝还是共享的方式。

    > print('old:', data)
    old: [1 2 3]
    
    > data[0] = 0
    
    > print('new:', data)
    new: [0 2 3]
    
    > print(o1)
    > print(o2)
    > print(o3)
    > print(o4)
    
    tensor([1., 2., 3.])
    tensor([1, 2, 3], dtype=torch.int32)
    tensor([0, 2, 3], dtype=torch.int32)
    tensor([0, 2, 3], dtype=torch.int32)
    

      可以发现,torch.Tensor()torch.tensor() 这两个函数都是对输入数据进行了拷贝,而 torch.as_tensor()torch.from_numpy() 这两个函数则是对输入数据进行了共享的方式。与复制数据相比,共享数据效率更高,占用的内存更少,因为数据不会写入内存中的两个位置。

      如果我们想把 torch.Tensor 对象转成 ndarray 类型的话,采取下面这种方式:

    > print(type(o3.numpy()))
    > print(type(o4.numpy()))
    <class 'numpy.ndarray'>
    <class 'numpy.ndarray'>
    

      不过这个方法只适用于 torch.as_tensor()torch.from_numpy() 这两种方式创建的 torch.Tensor 对象,我们再来进一步比较一下这两个方法的区别。

      torch.from_numpy() 函数只接受 numpy.ndarray 类型的输入,而torch.as_tensor() 函数可以接受各种类似Python数组的对象,包括其他PyTorch张量。

      综上所述,我们更推荐 torch.tensor()torch.as_tensor() 这两个函数,前者是一种直接调用的方式,后者是在需要调参的时候采用的方式。

      关于内存共享的机制,还有一些需要提的点:

    • 由于numpy.ndarray对象是在CPU上分配的,因此当使用GPU时,torch.as_tensor() 函数必须将数据从CPU复制到GPU。
    • torch.as_tensor() 的内存共享不适用于内置的Python数据结构,如列表。
    • torch.as_tensor() 的调用要求开发人员了解共享特性。这是必要的,这样我们就不会在没有意识到变更会影响多个对象的情况下无意中对底层数据进行不必要的更改。
    • 当 numpy.ndarray 对象和张量对象之间有许多来回操作时,torch.as_tensor() 性能的优越性会更大。

    9. tensor的reshape、squeeze和cat操作

      假设我们现在有一个秩为 2 、形状为 3 * 4 的张量:

    > t = torch.tensor([
        [1,1,1,1],
        [2,2,2,2],
        [3,3,3,3]
    ], dtype=torch.float32)
    

      在 PyTorch 中,我们有两种获取张量形状的方法:

    > t.size()
    torch.Size([3, 4])
    
    > t.shape
    torch.Size([3, 4])
    

      我们还可以采用下面的方式来获取张量的元素数:

    > torch.tensor(t.shape).prod()
    tensor(12)
    
    > t.numel()
    12
    

      于是我们可以进行 reshape 操作:

    > t.reshape([1,12])
    tensor([[1., 1., 1., 1., 2., 2., 2., 2., 3., 3., 3., 3.]])
    
    > t.reshape([2,6])
    tensor([[1., 1., 1., 1., 2., 2.],
            [2., 2., 3., 3., 3., 3.]])
    
    > t.reshape([3,4])
    tensor([[1., 1., 1., 1.],
            [2., 2., 2., 2.],
            [3., 3., 3., 3.]])
            
    > t.reshape(6,2)
    tensor([[1., 1.],
            [1., 1.],
            [2., 2.],
            [2., 2.],
            [3., 3.],
            [3., 3.]])
            
    > t.reshape(12,1)
    tensor([[1.],
            [1.],
            [1.],
            [1.],
            [2.],
            [2.],
            [2.],
            [2.],
            [3.],
            [3.],
            [3.],
            [3.]])
    

      我们传入的参数有 ([2, 6])(2, 6) 两种方式,这个都是可行的,但是我们要保证 传入参数的乘积和原始张量的元素个数要相等。

    > t.reshape(2,2,3)
    tensor(
    [
        [
            [1., 1., 1.],
            [1., 2., 2.]
        ],
    
        [
            [2., 2., 3.],
            [3., 3., 3.]
        ]
    ])
    

       在 PyTorch 中,还有一个 view() 函数,功能和 reshape() 函数是一样的,都可以改变张量的形状。

    > t.view(3,4)
    tensor([[1., 1., 1., 1.],
            [2., 2., 2., 2.],
            [3., 3., 3., 3.]])
            
    > t.view([2,6])
    tensor([[1., 1., 1., 1., 2., 2.],
            [2., 2., 3., 3., 3., 3.]])
    

      我们还可以通过 squeeze()unsqueeze() 这两个函数来改变输入张量的形状。

    • 压缩(squeeze)一个张量可以去掉长度为1的维度。

    • 解压缩(unsqueeze)一个张量可以增加一个长度为1的维度。

      从实际的例子来理解:

    > a = torch.tensor([[[1]],[[2]]])
    > print(a)
    tensor([[[1]],
    
            [[2]]])
            
    > print(a.squeeze())
    tensor([1, 2])
    
    > print(a.squeeze().unsqueeze(dim=0))
    tensor([[1, 2]])
    
    > print(a.squeeze().unsqueeze(dim=1))
    tensor([[1],
            [2]])
    

      squeeze()函数还有一个广泛的用途就是作为flatten()函数的一个子函数:

    def flatten(t):
        t = t.reshape(1, -1)
        t = t.squeeze()
        return t
    
    > a = torch.tensor([[[[1]],[[2]],[[3]]]])
    > print(a)
    tensor([[[[1]],
    
             [[2]],
    
             [[3]]]])
             
    > print(a.shape)
    torch.Size([1, 3, 1, 1])
    
    > print(a.reshape(1, -1)) 
    tensor([[1, 2, 3]])  # torch.Size([1, 3])
    
    > print(a.reshape(1, -1).squeeze()) # 可以看到实现了 flatten 的函数功能
    tensor([1, 2, 3])
    
    > print(a.reshape(1, -1).squeeze().shape)
    torch.Size([3])
    

      PyTorch 还提供了一个 cat() 函数,来实现张量的拼接(concatenate)。假设我们有如下两个张量:

    > t1 = torch.tensor([
        [1,2],
        [3,4]
    ])
    > t2 = torch.tensor([
        [5,6],
        [7,8]
    ])
    

      我们可以将它们按行(axis=0)拼接:

    > torch.cat((t1, t2), dim=0)
    tensor([[1, 2],
            [3, 4],
            [5, 6],
            [7, 8]])
    

      也可以将它们按列(axis=1)拼接:

    torch.cat((t1, t2), dim=1)
    tensor([[1, 2, 5, 6],
            [3, 4, 7, 8]])
    

      拼接之后的shape,可以通过所选拼接维度的值进行求和得到:

    > torch.cat((t1, t2), dim=0).shape
    torch.Size([4, 2])
    
    > torch.cat((t1, t2), dim=1).shape
    torch.Size([2, 4])
    

    10. flatten操作

      我们知道,CNN中的全连接层接收的是一个一维向量输入,而前面卷积层的输出都是 feature map 的形式,于是在全连接层之前,一定存在一个 flatten 操作,我们来看看,如何 flatten 张量中的某一个轴。

      首先创建三个张量,代表一个Batch中的三张图像:

    > a = torch.ones(4,4)
    > print(a)
    tensor([[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]])
    
    
    > b = torch.full((4,4),2)  # 此处的full()和numpy中的full()的作用类似
    > print(b)
    tensor([[2., 2., 2., 2.],
            [2., 2., 2., 2.],
            [2., 2., 2., 2.],
            [2., 2., 2., 2.]])
    
    > c = torch.full((4,4),3)
    > print(c)
    tensor([[3., 3., 3., 3.],
            [3., 3., 3., 3.],
            [3., 3., 3., 3.],
            [3., 3., 3., 3.]])
    

      CNN 中的 Batch 也是由单个张量表示的,于是我们需要将这三张图像连接起来,这里要用到 stack() 函数,后面会细讲。

    > t = torch.stack((a,b,c))
    > t
    tensor([[[1., 1., 1., 1.],
             [1., 1., 1., 1.],
             [1., 1., 1., 1.],
             [1., 1., 1., 1.]],
    
            [[2., 2., 2., 2.],
             [2., 2., 2., 2.],
             [2., 2., 2., 2.],
             [2., 2., 2., 2.]],
    
            [[3., 3., 3., 3.],
             [3., 3., 3., 3.],
             [3., 3., 3., 3.],
             [3., 3., 3., 3.]]])
    > t.shape
    torch.Size([3, 4, 4])
    

      我们这里默认的图像是灰度图,即通道数为1,于是我们可以通过 reshapeunsqueeze 这两种方式,进一步修改我们的 tensor.

    > t.reshape(3,1,4,4)
    tensor([[[[1., 1., 1., 1.],
              [1., 1., 1., 1.],
              [1., 1., 1., 1.],
              [1., 1., 1., 1.]]],
              
            [[[2., 2., 2., 2.],
              [2., 2., 2., 2.],
              [2., 2., 2., 2.],
              [2., 2., 2., 2.]]],
    
            [[[3., 3., 3., 3.],
              [3., 3., 3., 3.],
              [3., 3., 3., 3.],
              [3., 3., 3., 3.]]]])
    
    > t.unsqueeze(dim=1)
    tensor([[[[1., 1., 1., 1.],
              [1., 1., 1., 1.],
              [1., 1., 1., 1.],
              [1., 1., 1., 1.]]],
    
            [[[2., 2., 2., 2.],
              [2., 2., 2., 2.],
              [2., 2., 2., 2.],
              [2., 2., 2., 2.]]],
    
            [[[3., 3., 3., 3.],
              [3., 3., 3., 3.],
              [3., 3., 3., 3.],
              [3., 3., 3., 3.]]]])
    
    

      现在我们得到了一个四维张量,我们需要 flatten 里面的每一个图像张量,而不是整个张量,不妨先看看有哪些 flatten 整个张量的方法。

    > t.reshape(1,-1)[0]
    tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 2.,
            2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 3., 3., 3., 3.,
            3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.])
    > t.reshape(-1)
    tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 2.,
            2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 3., 3., 3., 3.,
            3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.])
    > t.view(t.numel())
    tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 2.,
            2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 3., 3., 3., 3.,
            3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.])
    > t.flatten()
    tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 2.,
            2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 3., 3., 3., 3.,
            3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.])
    

      在 CNN 中我们需要对同一个Batch中的每一张图片进行预测,因此上面对整个 tensor 进行 flatten 的做法是不可取的,我们需要对 tensor 中的(channels, width, height) 这三个维度进行展开,而 flatten() 函数中提供了对指定维度展开的方法。

    >> print(t)
    tensor([[[[1., 1., 1., 1.],
              [1., 1., 1., 1.],
              [1., 1., 1., 1.],
              [1., 1., 1., 1.]]],
    
            [[[2., 2., 2., 2.],
              [2., 2., 2., 2.],
              [2., 2., 2., 2.],
              [2., 2., 2., 2.]]],
    
            [[[3., 3., 3., 3.],
              [3., 3., 3., 3.],
              [3., 3., 3., 3.],
              [3., 3., 3., 3.]]]])
              
    > t.flatten(start_dim=1)
    tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
            [2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],
            [3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.]])
    
    > t.flatten(start_dim=2)
    tensor([[[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]],
    
            [[2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.]],
    
            [[3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.]]])
    

      注意,这里的 start_dim 参数,用来指定从哪一个轴开始进行 flatten 操作,默认是0。我们原本张量 t 的shape为 ( 3 , 1 , 4 , 4 ) (3,1,4,4) (3,1,4,4),如果 start_dim=1,那么我们最后得到的shape为 ( 3 , 16 ) (3,16) (3,16);如果start_dim=2,那么我们最后得到的shape为 ( 3 , 1 , 16 ) (3,1,16) (3,1,16)

    11. element-wise操作

      顾名思义,element-wise 类型操作表示两个张量中对应元素之间的操作,这要求两个张量的形状一致,假设我们有如下两个张量:

    > t1 = torch.tensor([
        [1,2],
        [3,4]], dtype=torch.float32)
    
    > t2 = torch.tensor([
        [9,8],
        [7,6]], dtype=torch.float32)
    

       加减乘除 都属于 element-wise 类型的操作:

    > t1 + t2
    tensor([[10., 10.],
            [10., 10.]])
            
    > t1 - t2
    tensor([[-8., -6.],
            [-4., -2.]])
    
    > t1 * t2
    tensor([[ 9., 16.],
            [21., 24.]])
            
    > t1 / t2
    tensor([[0.1111, 0.2500],
            [0.4286, 0.6667]])
    

       除此之外,张量与某个数值之间的加减乘除也是属于 element-wise 类型的操作:

    > print(t + 2)
    tensor([[3., 4.],
            [5., 6.]])
    
    > print(t - 2)
    tensor([[-1.,  0.],
            [ 1.,  2.]])
    
    > print(t * 2)
    tensor([[2., 4.],
            [6., 8.]])
    
    > print(t / 2)
    tensor([[0.5000, 1.0000],
            [1.5000, 2.0000]])
    
    > print(t1.add(2))
    tensor([[3., 4.],
            [5., 6.]])
    
    > print(t1.sub(2))
    tensor([[-1.,  0.],
            [ 1.,  2.]])
    
    > print(t1.mul(2))
    tensor([[2., 4.],
            [6., 8.]])
    
    > print(t1.div(2))
    tensor([[0.5000, 1.0000],
            [1.5000, 2.0000]])   
    

      这个看起来跟我们刚刚定义的 element-wise 运算有点冲突,我们刚讨论的是两个张量之间的运算,这里明明是一个标量和一个张量的运算。为什么也被视作是 element-wise 的运算呢?我们需要了解 PyTorch 中的 broadcast 机制。

      以 t1 + 2 为例,我们首先将标量 2 变换成 t1 的形状,然后再执行 element-wise 的操作,有点类似于 numpy 中的 broadcast_to() 函数。

    > np.broadcast_to(2, t1.shape)
    array([[2, 2],
            [2, 2]])
    

      所以,对于 t1 + 2 这个运算,实际上的过程为:

    > t1 + torch.tensor(
        np.broadcast_to(2, t1.shape)
        ,dtype=torch.float32
    )
    tensor([[3., 4.],
            [5., 6.]])
    

      broadcast 机制还可以进一步推广,低秩张量和高秩张量之间也可以进行 element-wise 的运算。

    > t1 = torch.tensor([
        [1, 1],
        [1, 1]
    ], dtype=torch.float32)
    
    > t2 = torch.tensor([2, 4], dtype=torch.float32)
    
    > np.broadcast_to(t2.numpy(), t1.shape)
    array([[2., 4.],
           [2., 4.]], dtype=float32)
    
    > t1 + t2
    tensor([[3., 5.],
            [3., 5.]])
    

       低秩张量的每一个轴的元素个数要么和对应高秩张量轴的元素个数相等,要么元素数为1,才能顺利进行 broadcast 操作。

    > t3 = torch.ones(3,3,2) # 高秩张量形状为(3,3,2)
    > t3
    tensor([[[1., 1.],
             [1., 1.],
             [1., 1.]],
    
            [[1., 1.],
             [1., 1.],
             [1., 1.]],
    
            [[1., 1.],
             [1., 1.],
             [1., 1.]]])
    
    > t4 = torch.tensor([2,4],dtype=torch.float32) # 此时低秩张量形状为(2),满足条件
    > t3 + t4
    tensor([[[3., 5.],
             [3., 5.],
             [3., 5.]],
    
            [[3., 5.],
             [3., 5.],
             [3., 5.]],
    
            [[3., 5.],
             [3., 5.],
             [3., 5.]]])
    
    > t5 = torch.tensor([[2, 4]],dtype=torch.float32) # 此时张量形状为(1,2),满足条件
    > t3 + t5
    tensor([[[3., 5.],
             [3., 5.],
             [3., 5.]],
    
            [[3., 5.],
             [3., 5.],
             [3., 5.]],
             
            [[3., 5.],
             [3., 5.],
             [3., 5.]]])
    
    > t6 = torch.tensor([[2, 4],[1, 3]],dtype=torch.float32) # 张量形状为(2,2),不符条件
    > t3 + t6 # 输出报错
    RuntimeError: The size of tensor a (3) must match the size of tensor b (2) at non-singleton dimension 1
    
    > t7 = torch.tensor([[2, 4],[1, 3],[0, 5]],dtype=torch.float32) # 张量形状为(3,2),满足条件
    > t3 + t7
    tensor([[[3., 5.],
             [2., 4.],
             [1., 6.]],
    
            [[3., 5.],
             [2., 4.],
             [1., 6.]],
    
            [[3., 5.],
             [2., 4.],
             [1., 6.]]])
    
    > t8 = torch.tensor([[[2, 4],[1, 3],[0, 5]]],dtype=torch.float32) # 张量形状为(1,3,2),满足条件
    > t3 + t8
    tensor([[[3., 5.],
             [2., 4.],
             [1., 6.]],
    
            [[3., 5.],
             [2., 4.],
             [1., 6.]],
    
            [[3., 5.],
             [2., 4.],
             [1., 6.]]])
    

      比较大小的操作也是 element-wise类型的,一个张量与某一个数值进行比较,返回的是一个和原始张量形状相同、取值为bool类型的张量。

    > t = torch.tensor([[0,5,0],[6,0,7],[0,8,0]], dtype=torch.float32)
    
    > t.eq(0)
    tensor([[ True, False,  True],
            [False,  True, False],
            [ True, False,  True]])
    
    > t.eq(0).dtype
    torch.bool
    
    > t.ge(0)
    tensor([[True, True, True],
            [True, True, True],
            [True, True, True]])
    
    > t.gt(0)
    tensor([[False,  True, False],
            [ True, False,  True],
            [False,  True, False]])
    
    > t.le(0)
    tensor([[ True, False,  True],
            [False,  True, False],
            [ True, False,  True]])
    
    > t.lt(0)
    tensor([[False, False, False],
            [False, False, False],
            [False, False, False]])
    

      PyTorch中内置的 element-wise 类型的函数:

    > t = torch.tensor([[1,-2,3],[-4,5,-6],[7,-8,9]],dtype=torch.float32)
    > t
    tensor([[ 1., -2.,  3.],
            [-4.,  5., -6.],
            [ 7., -8.,  9.]])
            
    > t.abs()
    tensor([[1., 2., 3.],
            [4., 5., 6.],
            [7., 8., 9.]])
            
    > t.abs().sqrt()
    tensor([[1.0000, 1.4142, 1.7321],
            [2.0000, 2.2361, 2.4495],
            [2.6458, 2.8284, 3.0000]])
    
    > t.neg()
    tensor([[-1.,  2., -3.],
            [ 4., -5.,  6.],
            [-7.,  8., -9.]])
    

      最后说一下,以下词语名称不同,但是都代表着 element-wise 类型的操作:

    • element-wise
    • component-wise
    • point-wise

    12. reduction操作

      reduction 操作指的是减少某个张量中元素个数的操作,我们前面提过的 reshapeelement-wise 操作都不会改变张量中的元素个数,我们通过示例来看:

    t = torch.tensor([[0,1,0],[2,0,2],[0,3,0]],dtype=torch.float32)
    >>> t
    tensor([[0., 1., 0.],
            [2., 0., 2.],
            [0., 3., 0.]])
    
    > t.sum() # 输出张量元素个数为1
    tensor(8.)
    
    > t.numel() # num of element的缩写
    9
    >>> type(t.numel())
    <class 'int'>
    
    > t.prod()
    tensor(0.)
    
    > t.mean()
    tensor(0.8889)
    
    > t.std()
    tensor(1.1667)
    

      并不是只把元素个数缩减为1的操作,叫做 reduction ops,下面的操作也是:

    > t = torch.tensor([[1,1,1,1],[2,2,2,2],[3,3,3,3]],dtype=torch.float32)
    > t
    tensor([[1., 1., 1., 1.],
            [2., 2., 2., 2.],
            [3., 3., 3., 3.]])
    > t.shape
    torch.Size([3, 4])
    
    > t.sum(dim=0)
    tensor([6., 6., 6., 6.])
    
    > t.sum(dim=1)
    tensor([ 4.,  8., 12.])
    

      如何理解 dim=0dim=1 所得的两种不同的结果呢?

    > t.sum(dim=0) 
    > 可以理解为其他轴的索引保持不变,只改变第一个轴的元素索引值,如下所示
    t[0][0] + t[1][0] + t[2][0] 
    t[0][1] + t[1][1] + t[2][1] 
    t[0][2] + t[1][2] + t[2][2]
    t[0][3] + t[1][3] + t[2][3]
    
    > t.sum(dim=1) 
    > 可以理解为其他轴的索引保持不变,只改变第二个轴的元素索引值,如下所示
    t[0][0] + t[0][1] + t[0][2] + t[0][3]
    t[1][0] + t[1][1] + t[1][2] + t[1][3]
    t[2][0] + t[2][1] + t[2][2] + t[2][3]
    

      另外一种常见的 reduction 操作是 argmax(),作用是返回张量中最大元素值的索引,我们举例说明:

    > t = torch.tensor([
        [1,0,0,2],
        [0,3,3,0],
        [4,0,0,5]], dtype=torch.float32)
    
    > t.max()
    tensor(5.)
    
    > t.argmax()
    tensor(11)
    
    > t.flatten()
    tensor([1., 0., 0., 2., 0., 3., 3., 0., 4., 0., 0., 5.])
    

      我们还可以指定轴,返回轴上每个张量的最值。

    > t.max(dim=0)
    torch.return_types.max(values=tensor([4., 3., 3., 5.]),indices=tensor([2, 1, 1, 2]))
    
    > t.argmax(dim=0)
    tensor([2, 1, 1, 2])
    
    > t.max(dim=1)
    torch.return_types.max(values=tensor([2., 3., 5.]),indices=tensor([3, 2, 3]))
    
    > t.argmax(dim=1)
    tensor([3, 2, 3])
    

      这里 dim=0dim=1的作用和上面讨论的 sum() 是一致的,不再赘述。

      最后我们再来聊聊如何访问一个张量中的内部元素:

    > t = torch.tensor([
        [1,2,3],
        [4,5,6],
        [7,8,9]], dtype=torch.float32)
    
    > t.mean()
    tensor(5.)
    
    > t.mean().item() # item() 适用于标量
    5.0
    
    > t.mean(dim=0).tolist() # 返回 Python list 类型
    [4.0, 5.0, 6.0]
    
    > t.mean(dim=0).numpy() # 返回 ndarray 类型
    array([4., 5., 6.], dtype=float32)
    

      到现在为止,我们已经对 PyTorch 的张量有一个基础的认识,我们现在对张量的使用还仅处于一个非常原始的阶段,在一个篇章,我们将结合 Fashion Mnist 数据集来进一步挖掘 PyTorch 的强大之处。

    展开全文
  • 这是将Torch机器学习生态系统安装到运行Ubuntu 14.04的GPU EC2实例的指南。 注意:在这些步骤之后,我创建了Community EC2 AMI并使其可用,名称为torch-ubuntu-14.04-cuda-7.0-28和ami-id ami-c79b7eac 。 创建...
  • 1.torch使用提示 AttributeError: module 'torch.jit' has no attribute '_script_if_tracing' 解决办法:原因是torch与torchvision版本不匹配导致的,重新安装torchvision即可 pip install torchvision==0.5.0

    1.torch使用提示

    AttributeError: module 'torch.jit' has no attribute '_script_if_tracing'

    解决办法:原因是torch与torchvision版本不匹配导致的,重新安装torchvision即可

    pip install torchvision==0.5.0

    展开全文
  • gtsrb.torch, 基于 Torch的交通标志识别 gtsrb.torch本文介绍了如何使用 Torch 在 GTSRB数据集上训练卷积神经网络,以及如何用空间转换器层来提高 state-of-the...要求安装 Torch ( 请参见本指南中的 )( 可选) 安装空间
  • 几种最常见的机器学习的算法平台的安装,Tensorflow ,caffe 和 Torch的详细安装,我没有使用Anacanda来安装python,如果使用Anacanda来安装会省去很多步骤,因为Anacanda中已经集成了python中许多常见的库,不过...

    1.TensorFlow的安装

    补充说明:
    TensorFlow的安装主要参考的是下面这个网站:
    网址:http://blog.csdn.net/v_july_v/article/details/52658965
    (非常感谢~)

    这个网站中的配置为:
    GTX 1070 cuda 8.0 Ubuntu 14.04 cudnn 5.1 tensorflow gpu

    由于使用的是 GTX1070 所以必须下载 cuda8.0!其他低版本的GPU可以下载以前的cuda!网上很多教程说必须下载 cudnn v4 的版本,但是我的实测表明 v5 的版本也是可以的!

    步骤主要参考tensorflow的官网(任何安装还是都要先看一下官网~):

    https://github.com/tensorflow/tensorflow/blob/master/tensorflow/g3doc/get_started/os_setup.md

    1.1 首先安装一些tensorflow必须的依赖包(与python有关)

    $ sudo apt-get install python-pip python-dev Python-scipy Pythoy-numpy Git

    1.2 下载tensorflow的软件包 (一定要下载GPU版本的!

    官网提示,在安装了上述的软件包之后就可以使用 pip 命令 下载tensorflow:

    (依据自己的python版本进行选择)
    
    # Python 2
    $ sudo pip install --upgrade $TF_BINARY_URL
    
    # Python 3
    $ sudo pip3 install --upgrade $TF_BINARY_URL

    个人建议,可以从github上下载安装包:

    $ git clone --recurse-submodules https://github.com/tensorflow/tensorflow

    1.3 为了能够让tensorflow使用CUDA的库,需要在环境变量中配置CUDA的路径

    $ sudo  gedit ~/.bash_profile
    输入:
    export  LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64"
    export  CUDA_HOME=/usr/local/cuda
    

    保存,之后运行下列的命令:

    $ source  ~/.bash_profile

    此时,可以验证一下tensflow是否下载安装正确:
    首先,在命令行输入:$ python
    出现>>>之后,依次输入以下:

    >>> import tensorflow as tf
    >>> hello = tf.constant('Hello, TensorFlow!')
    >>> sess = tf.Session()
    >>> print(sess.run(hello))
    Hello, TensorFlow!
    >>> a = tf.constant(10)
    >>> b = tf.constant(32)
    >>> print(sess.run(a + b))
    42
    >>>

    出现以上结果表明安装正确~~~

    下面是tensorflow的配置和CUDA与tensorflow的连接

    1.4 Bazel安装

    参考网页: https://www.bazel.io/versions/master/docs/install.html

    这里写图片描述

    选择UBUNTU版本

    注意!!! 官网上提示:
    If you are running Ubuntu Wily (15.10), you can skip this step. But for Ubuntu Trusty (14.04 LTS) users, since OpenJDK 8 is not available on Trusty, please install Oracle JDK 8:
    如果是15.10以上的版本要安装的是OpenJDK 8, 而由于14.04版本没有包含OpenJDK 8,只能够安装Oracle JDK 8版本,步骤如下(仅限于Ubuntu14.04版本):

    1) Install JDK 8

    $ sudo add-apt-repository ppa:webupd8team/java
    $ sudo apt-get update
    $ sudo apt-get install oracle-java8-installer

    2) Add Bazel distribution URI as a package source (one time setup)

    $ echo "deb [arch=amd64] http://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
    $ curl https://storage.googleapis.com/bazel-apt/doc/apt-key.pub.gpg | sudo apt-key add

    3) Update and install Bazel

    $ sudo apt-get update && sudo apt-get install bazel
    $ sudo apt-get upgrade bazel

    4) Install other required packages

    $ sudo apt-get install pkg-config zip g++ zlib1g-dev unzip

    5) 下载Bazel的包并使用Installer安装

    网址: https://github.com/bazelbuild/bazel/releases

    这里写图片描述

    下载linux-x86_64的版本!

    6) 安装Bazel

    将下载的Bazel安装包放在/home目录下,在命令行输入:

    $ chmod +x  PATH_TO_INSTALL.SH
    $ ./PATH_TO_INSTALL.SH --user

    注意,这里的PATH_TO_INSTALL.SH要改为我们下载的安装包的名称(进入/home文件夹下,输入B按Tab键会自动补全名称!)

    7) 安装好之后,接着下载一些必要的依赖包

    # For Python 2.7:
    $ sudo apt-get install python-numpy swig python-dev python-wheel
    # For Python 3.x:
    $ sudo apt-get install python3-numpy swig python3-dev python3-wheel

    8) 安装numpy库

     git clone git://github.com/numpy/numpy.git numpy

    1.5 Tensorflow安装

    安装好的Tensorflow会在home下有一个独立的文件夹,在命令行下进入Tensorflow所在的目录,输入如下的命令进行配置

    $ ./configure

    出现如下的内容,按要求回答问题:

    Please specify the location of python. [Default is /usr/bin/python]: (python的默认地址不用改)
    Do you wish to build TensorFlow with Google Cloud Platform support? [y/N] N
    No Google Cloud Platform support will be enabled for TensorFlow
    Do you wish to build TensorFlow with GPU support? [y/N] y (选择使用GPU!)
    GPU support will be enabled for TensorFlow
    Please specify which gcc nvcc should use as the host compiler. [Default is /usr/bin/gcc]:
    Please specify the Cuda SDK version you want to use, e.g. 7.0. [Leave empty to use system default]: 7.5 (这里依据安装的CUDA版本填写,我的是7.5)
    Please specify the location where CUDA 7.5 toolkit is installed. Refer to README.md for more details. [Default is /usr/local/cuda]: (CUDA的默认地址,不用改)
    Please specify the cuDNN version you want to use. [Leave empty to use system default]: 5(我的cudnn是v5的版本)
    Please specify the location where cuDNN 5 library is installed. Refer to README.md for more details. [Default is /usr/local/cuda]: (默认地址,不用改)
    Please specify a list of comma-separated Cuda compute capabilities you want to build with.
    You can find the compute capability of your device at: https://developer.nvidia.com/cuda-gpus.
    Please note that each additional compute capability significantly increases your build time and binary size.
    [Default is: “3.5,5.2”]: 3.0 (写3.0也可以)

    Setting up Cuda include
    Setting up Cuda lib
    Setting up Cuda bin
    Setting up Cuda nvvm
    Setting up CUPTI include
    Setting up CUPTI lib64
    Configuration finished

    1.6使用Bazel配置一些CUDA和PIP的环境

    $ bazel build -c opt //tensorflow/tools/pip_package:build_pip_package
    # To build with GPU support:
    $ bazel build -c opt --config=cuda //tensorflow/tools/pip_package:build_pip_package
    
    $ bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg
    
    # The name of the .whl file will depend on your platform.
    $ sudo pip install /tmp/tensorflow_pkg/tensorflow-0.11.0rc0-py2-none-any.whl
    (注意: 这里tensorflow-0.11.0rc0-py2-none-any.whl版本要依据自己的定,如果并不知道自己的Tensflow是什么版本,可以先安装下面一个步骤,下面一个步骤装完会显示例如“tensorflow-0.11.0rc0-py2”这样的版本)
    
    

    1.7设置一些Tensflow中的python环境

    bazel build -c opt //tensorflow/tools/pip_package:build_pip_package
    # To build with GPU support:
    bazel build -c opt --config=cuda //tensorflow/tools/pip_package:build_pip_package
    
    mkdir _python_build
    cd _python_build
    ln-s ../bazel-bin/tensorflow/tools/pip_package/build_pip_package.runfiles/org_tensorflow/* .
    ln-s ../tensorflow/tools/pip_package/* .
    python setup.py develop

    1.8 Tensorflow的GPU训练测试(检测能否用GPU加速)

    $ cd tensorflow/models/image/mnist
    $ python convolutional.py

    显示:
    Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
    Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
    Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
    Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.
    Extracting data/train-images-idx3-ubyte.gz
    Extracting data/train-labels-idx1-ubyte.gz
    Extracting data/t10k-images-idx3-ubyte.gz
    Extracting data/t10k-labels-idx1-ubyte.gz
    Initialized!
    Epoch 0.00
    Minibatch loss: 12.054, learning rate: 0.010000
    Minibatch error: 90.6%
    Validation error: 84.6%
    Epoch 0.12
    Minibatch loss: 3.285, learning rate: 0.010000
    Minibatch error: 6.2%
    Validation error: 7.0%

    补充: Tflearn的安装

    Tflean是一个集成度很高的用于在Tensorflow中用于搭建CNN等网络的工具。

    网址:tflearn.org (点击左侧的installation)

    输入:$ sudo pip install tflearn


    2.Caffe 的安装

    2.1 caffe 的安装主要参考caffe的官网:

    安装指南: http://caffe.berkeleyvision.org/installation.html

    1.首先,安装一些caffe使用的依赖库:
    这里写图片描述

    由于我们使用的是UBUNTU14.04的系统,所以选择UBUNTU installation这个选项。

    接着,安装一些必要的依赖库:

    $sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libhdf5-serial-dev protobuf-compiler
    $sudo  apt-get  install --no-install-recommends libboost-all-dev

    再接着,安装BLAS:
    BLAS:
    install ATLAS by sudo apt-get install libatlas-base-dev or install OpenBLAS or MKL for better CPU performance.

    其中,$ sudo apt-get install libatlas-base-dev 安装的是ATLAS,也可以选择安装OpenBLAS或者MKL,MKL的性能比ATLAS好,但是安装麻烦,安装好之后需要配置环境变量,如果需要安装MKL,可以采用下面的方式(这里我安装的是ATLAS):

    首先,下载并安装英特尔® 数学内核库 Linux* 版MKL,下载链接是:

    https://software.intel.com/en-us/intel-education-offerings

    请下载Student版,先申请,然后会立马收到一个邮件(里面有安装序列号),打开照着下载就行了。下载完之后,要把文件解压到home文件夹(或直接把tar.gz文件拷贝到home文件夹,为了节省空间,安装完记得把压缩文件给删除喔~),或者其他的ext4的文件系统中。

    接下来是安装过程,先授权,然后安装:

    $ tar zxvfparallel_studio_xe_2015_update3.tgz(如果你是直接拷贝压缩文件过来的)
    $ chmod a+xparallel_studio_xe_2015_update3 –R
    $ sudo  /home/ls/ parallel_studio_xe_2015_update3/install_GUI.sh
    
    安装序列号:SKCG-XCR7XLXX

    MKL的环境变量配置:

    首先,新建intel_mkl.conf, 并编辑之:

    $ sudo  gedit  /etc/ld.so.conf.d/intel_mkl.conf
    /opt/intel/lib/intel64
    /opt/intel/mkl/lib/intel64

    完成Lib文件的连接操作,执行:

    $ sudo ldconfig –v

    2.2Caffe软件的安装

    首先,我们需要去caffe的github官网下载caffe的文件:

    $ git clone git://github.com/BVLC/caffe.git

    等待安装好了之后,进入caffe文件所在的目录(一般安装好之后,会在主文件加下出现一个caffe的文件夹,在命令行想要进入这个文件夹就输入: cd /home/audi/caffe , audi是我们自己的电脑账户名,需要依情况修改)

    $ cp Makefile.config.example Makefile.config

    上面一句话是复制一份caffe的配置文件,在配置文件里面可以修改一些配置,复制好了之后,进入配置文件Makefile.config配置:

    $ vi Makefile.config

    打开配置文件,里面是这样的:
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述

    以上是Makefile.config中所有需要配置的选项的说明,在官网上给出了如下的说明:

    For CPU & GPU accelerated Caffe, no changes are needed.
    For cuDNN acceleration using NVIDIA’s proprietary cuDNN software, uncomment the USE_CUDNN := 1 switch in Makefile.config. cuDNN is sometimes but not always faster than Caffe’s GPU acceleration.
    For CPU-only Caffe, uncomment CPU_ONLY := 1 in Makefile.config.

    如果是使用CPU和GPU加速的电脑,配置文件可以不用修改(修改的方式,哪个需要就将后面的值变为1,然后前面的#去掉),如果使用cudnn,那么就将配置文件里面第一行的USE_CUDNN前的#去掉。如果没有GPU的话就只将第二行的中的CPU_ONLY前的#去掉,修改完毕之后,输入:,然后输入wq保存文件。

    修改完配置文件之后,执行以下的3句话:

    $make all
    $make test
    $make runtest

    能够顺利编译通过就没有什么问题了,如果提示一些类似于找不到lib之类的,可能是前面的cudnn和CUDA的环境变量没有配置好,如果想再次修改配置文件但是修改完之后执行make这三句话出错,建议去主文件夹下将caffe删除,再下载一次,然后重新配置

    如果以上环节都没有问题,那么通过下面的mnist例子就可以试验caffe安装的有效性了:

    首先,获取mnist数据(注意,新版的caffe所有的命令执行必须在caffe/这个根目录下!!!)

    $ cd  /home/audi/caffe
    $ sh ./data/mnist/get_mnist.sh

    然后,将下载的数据转换成能够在caffe中使用的lmdb格式:

    $ sh ./examples/mnist/create_mnist.sh

    最后,开始,训练cnn,注意:在这个mnist的文件下有个配置文件lenet_solver.prototxt,这个文件里面最后一行会规定使用的是CPU还是GPU,一定要依据情况做修改(默认是GPU)

    $ cd caffe/examples/mnist
    $ vi lenet_solver.prototxt

    拉到文件的最后一行,将solver_mode修改成:

    solver_mode: GPU  (只有CPU,这里就写成CPU)

    配置好了之后就可以开始训练网络了,回到caffe根目录下:

    $ sh ./examples/mnist/train_lenet.sh

    会出现以下的训练过程:
    这里写图片描述

    这就表示,caffe安装成功了,并且GPU也可以用了~~~

    再接着,可以选择安装Python:

    Python (optional): if you use the default Python you will need to :

    $ sudo apt-get install  python-devpackage 

    to have the Python headers for building the pycaffe interface.

    补充:

    caffe中python环境的安装:

    1) 安装pycaffe必须的一些依赖项:

    $sudo apt-get install -y python-numpy python-scipy python-matplotlib python-sklearn python-skimage python-h5py python-protobuf python-leveldb python-networkx python-nose python-pandas python-gflags  Cython  ipython
    
    $ sudo apt-get install -y protobuf-c-compiler protobuf-compiler

    2) 切换到Caffe的文件夹,生成Makefile.config配置文件,执行:

    $ cd  /caffe-master
    $ cp  Makefile.config.example  Makefile.config

    3) 配置Makefile.config文件(仅列出修改部分)

    $ sudo gedit /caffe-master/Makefile.config

    a. 配置一些引用文件(增加部分主要是解决新版本下,HDF5的路径问题)可以验证一下路径是否正确

    INCLUDE_DIRS:=$(PYTHON_INCLUDE)/usr/local/include/usr/lib/x86_64-linux-gnu/hdf5/serial/include
    LIBRARY_DIRS := $(PYTHON_LIB)/usr/local/lib /usr/lib /usr/lib/x86_64-linux-gnu/hdf5/serial

    b. 配置路径,实现caffe对Python接口的支持

    PYTHON_LIB := /usr/local/lib

    (在新版的caffe中,打开Makefile配置文件,python的路径都是默认设定好的,看看有关Python路径配置前的#有没有去掉,另外,如果用的是Anaconda来配置python的环境,则需要先下载安装Anaconda,然后在caffe的配置文件里面也要选择python的路径为Anaconda的路径!我这里没有使用Anaconda!所以配置文件里python的路径为python2.7的所在路径!)

    4) 编译caffe!
    “-j8”是使用CPU的多核进行编译,可以极大地加速编译的速度,建议使用。

    $ make all-j8    (这个是配置完所有的caffe文件之后的一个步骤!!!)
    $ make test-j8
    $ make runtest -j8

    编译Python用到的caffe文件

    $ make pycaffe -j8  (注意,配置完caffe的python环境之后,一定要make一下pycaffe!)

    如果遇到warning,make:*[build_release/src/caffe…..]error问题可不用管

    5) 此时,在Python中还无法连接到caffe的环境,我们需要将caffe的环境放入python的路径中(把环境变量放入 ~./bashrc文件中):

    $ sudo vi ~./bashrc
    将一下两句添加到文件中:
    export PYTHONPATH=~/caffe/python
    export JAVA_HOME=”~/caffe/python”    
    最后,让文件生效:
    $ source ~./bashrc

    6) 最后,在终端输入python,然后import caffe 成功,OK!

    最后,安装一些lib的包(注意,官网上提示说CUDA8.0只适用于UBUNTU16.04,而UBUNTU14.0底下所有的依赖包都已经打包好了,可以直接下载,我们使用的是UBUNTU14.04,所以直接运行下面的命令):

    $ sudo apt-get install libgflags-dev libgoogle-glog-dev liblmdb-dev

    最后,OPenCV也是caffe编译必须用到的库,我们也需要安装:

    首先,下载安装脚本:https://github.com/bearpaw/Install-OpenCV
    然后,进入文件的目录:Install-OpenCV/Ubuntu/2.4 (这里下载的是2.4.10所以目录是2.4)
    执行脚本:

    $ sh sudo ./opencv2_4_10.sh

    补充:1. 安装python中一些必要的库
    (都是为了后续能够在caffe中使用R-CNN图像识别库安装的一些python库)

    Python在科学计算的应用越来越丰度,而hdf(5)数据的应用也非常广泛。python提供了h5py包供开发者处理数据(hdf(5)数据是在著名的图像识别程序:R-CNN/Fast-RCNN/Faster-RCNN中使用的数据格式):

    网址: http://www.h5py.org/

    (1)使用: sudo apt-get install python-pip 安装 pip 工具,然后使用 pip install numpy 和 pip install numpy 安装基本环境。
    (2)使用: sudo apt-get install libhdf5-dev 安装 hdf 的开发库(重要)。否则会报出:

    #include “hdf5.h”
    compilation terminated.
    error: command ‘gcc’ failed with exit status:1

    (3)安装HDF5: 按照官方文档的说明就可以
    地址:
    ftp://ftp.hdfgroup.org/HDF5/current/src/unpacked/release_docs/INSTALL

    首先,下载HDF5的安装包:
    地址: ftp://ftp.hdfgroup.org/HDF5/current/src

    这里写图片描述

    下载.tar.gz格式的文件。

    然后,执行:

    $ tar zxf hdf5-X.Y.Z.tar.gzX.Y.Z表示hdf5的版本号)
    $ cd hdf5-X.Y.Z
    $ ./configure --prefix=/usr/local/hdf5
    $ sudo make
    $ sudo make check                # run test suite.
    $ sudo make install
    $ sudo make check-install        # verify installation.

    (4)使用:sudo pip install h5py 安装h5py库, 当你看到 Successfully install h5py. Cleaning up…就大功告成了。

    2.安装 R-CNN需要使用的一些python库

    Selective Search

    选择性搜索,选择性搜索综合了蛮力搜索(exhaustive search)和分割(segmentation)的方法,意在:找出可能的目标位置来进行物体的识别。

    安装的网址: https://github.com/AlpacaDB/selectivesearch
    安装语句: $ pip install selectivesearch

    3.SVM分类器的包

    安装语句: $ pip install sklearn


    3.Torch安装

    Torch 的安装地址: https://github.com/torch/torch7
    Torch 的安装教程: http://torch.ch/docs/getting-started.html

    安装步骤:

    1.ubuntu终端窗口输入(以下所有命令均在root用户下执行):

    apt-get update (更新源)

    2.打开搭建 torch7 网址

    git clone https://github.com/torch/distro.git ~/torch --recursive (克隆torch到~/torch文件下)
    
    cd ~/torch; bash install-deps; (执行install-deps)
    ./install.sh (执行程序)
    
    source ~/.bashrc (Ubuntu14.04一般情况执行这个,更新.bashrc文件)
    source ~/.zshrc  (不放心了把这个也执行了)
    

    如果用Lua5.2就执行如下,没有就跳过

    第一个git忽略,开始搭建时候已经下载过了

    cd ~/torch (进入torch文件)
    ./clean.sh (执行clean.sh)
    TORCH_LUA_VERSION=LUA52 ./install.sh(执行命令)
    
    luarocks install image (安装image)
    luarocks list (安装list)
    th (测试能否用torch7,出现如上图标志,表示能用)

    如果在安装过程中出现 torch7 的环境变量未能添加到PATH内,解决办法如下:
    在终端输入:

    vi /etc/profile 
    进入文件后,在最后添加如下命令: 
    PATH=~/torch/install/bin:$PATH

    按Esc 接着输入: q (退出)
    执行 source /etc/profile (更新一下)

    展开全文
  • 网上的教程大多十分复杂,实际上使用logging非常简单, 三行代码就好了 我使用logging是为了方便调试, 因为输出框缓存的数量是有限的,如果把输出打印到文件中观察使用体验会好很多,因为这三行代码的功能就是为了...
  • torch-0.4.1默认安装cuda版本为9.0,但是对于本机cuda-10.0版本的需要单独安装为cuda-10.0 安装torch时,不要添加官网指令的后缀的-c pytorch, 否则编译很慢 六、CUDA安装 CUDA官网(所有版本安装包列表),wget 指令...
  • fb.resnet.torch, http中ResNet的Torch 实现 Torch 中的 ResNet培训方法利用深度残差学习技术实现对图像识别的剩余网络训练,并利用语言对它的进行了训练。 al 。我们写了一个更详细的博客文章讨论这个代码,并在...
  • 所以我们在初始化 data loader 的时候需要使用到 torch.utils.data.distributed.DistributedSampler 这个特性: train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) train_loader = ...
  • 从训练循环中,你注意到只能在train_loss上调用backward。因此,误差只会根据训练集来进行反向传播。验证集用于在未用于训练的数据上对模型输出的准确性进行独立的评估。 好奇的读者此时可能会有一个问题。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,771
精华内容 1,108
热门标签
关键字:

torch指南