精华内容
下载资源
问答
  • 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深度指南-torch与Tensor常用操作方法import torchtorch.Tensor会继承某些torch的某些数学运算,例如sort, min/max....不需要调用相应的torch.funciton进行处理,下文中如果是torch/Tensor即表示该函数可以直接...

    pytorch深度指南-torch与Tensor常用操作方法

    import torch

    torch.Tensor会继承某些torch的某些数学运算,例如sort, min/max....不需要调用相应的torch.funciton进行处理,下文中如果是torch/Tensor即表示该函数可以直接对self的tensor使用,也可以使用torch给的相应函数接口

    torch/Tensor.reshape(input, shape) → Tensor

    指定tensor新的shape,reshape过后不会更该数据量和数据格式,只是对数据的shape做了调整,因此要保证reshape前后元素个数一致。 参数:

    input(tensor) - 输入tensor

    shape(tuple or *size) - 新的shape 如果还剩下一个维度,很好,你可以直接使用-1来替代,表示这个维度中应该有的元素数量

    torch/Tensor.view()

    与reshape功能类似,将源tensor的shape改变指定形状。

    原文中这样描述 Returned tensor will be a view of input. Otherwise, it will be a copy. Contiguous inputs and inputs with compatible strides can be reshaped without copying, but you should not depend on the copying vs. viewing behavior.二者区别:当tensor都为contiguous类型(邻近模式)时,两个函数并无差异,使用原来的数据内容,不会复制一份新的出来;如果tensor不是,例如经过了transpose或permute之后,需要contiguous然后再使用view。reshape其实就是.contiguous+view,这样不会开辟新的空间存放tensor,而是共享原来的数据内存。

    torch.arange(10).reshape((2,5))

    tensor([[ 0., 1., 2., 3., 4.],

    [ 5., 6., 7., 8., 9.]])

    torch.arange(10).reshape(5, -1)#可以看到新的shape是(5,2),使用-1自动求剩余最后一个维度

    tensor([[ 0., 1.],

    [ 2., 3.],

    [ 4., 5.],

    [ 6., 7.],

    [ 8., 9.]])

    torch.index_select(input, dim, index, out=None)

    指定在哪个轴上,index是多少,注意index要是一个tensor, dim和index确定了一个维度的坐标$(dim_1=index_i,....dim_n=index)$

    a = torch.randn([3,4])

    print(a)

    a.index_select(0,torch.tensor([2])).reshape(2,2)#

    tensor([[ 0.0334, 0.9123, -1.2300, -0.9336],

    [-0.8364, 0.6584, 0.6878, -2.5896],

    [ 0.1862, -0.3752, 0.4150, -1.4008]])

    tensor([[ 0.1862, -0.3752],

    [ 0.4150, -1.4008]])

    torch.linespace(start, end, steps=100, out=None)

    返回一个一维tensor,包含step个元素,每个元素之间等间距,依次递增$\frac{end-start}{step}$

    torch.linspace(0,1,10, dtype=torch.float32)

    tensor([ 0.0000, 0.1111, 0.2222, 0.3333, 0.4444, 0.5556, 0.6667,

    0.7778, 0.8889, 1.0000])

    Tensor.repeat(input, *size)

    把输入的input当做一个基本模块m,扩张成size的tensor,其中每个元素为m,最后返回的Tensor的shape为() *size必须比input的维度要高,

    if input和size维度相等:

    input = (a,b)

    *size = (c,d)

    out = (a×c, b×d)

    size > input

    input = (a,b)

    *size = (c,d,e)

    out = (c, d×a,e×b)

    torch.Tensor.repeat(torch.tensor([2,3]),2,4,3).shape

    torch.Size([2, 4, 6])

    torch/Tensor.nonzero()

    返回一个包含输入input中非零元素索引的张量,输出张量中非零元素的索引 若输入input有n维,则输出的索引张量output形状为z * n, 这里z是输入张量input中所有非零元素的个数

    a = torch.eye(3,3)

    print('a:', a)

    a.nonzero()#所有非0的坐标,注意返回的每个元素都是一个完整的坐标index~

    a: tensor([[ 1., 0., 0.],

    [ 0., 1., 0.],

    [ 0., 0., 1.]])

    tensor([[ 0, 0],

    [ 1, 1],

    [ 2, 2]])

    b = torch.arange(8).reshape(2,2,2)

    print('b:', b)

    b.nonzero()#z=7,n=3,输出(7*3)矩阵

    b: tensor([[[ 0., 1.],

    [ 2., 3.]],

    [[ 4., 5.],

    [ 6., 7.]]])

    tensor([[ 0, 0, 1],

    [ 0, 1, 0],

    [ 0, 1, 1],

    [ 1, 0, 0],

    [ 1, 0, 1],

    [ 1, 1, 0],

    [ 1, 1, 1]])

    torch/Tensor.chunk(tensor, chunks, dim=0)

    将一个tensor在指定维度上分成chunks个数据块,为cat的逆过程,最后一个块可能会小一些,返回的是一个元组,每个元素都是其中一块 参数: tensor (Tensor) – 输入Tensor chunks (int) – 分成几块的数量 dim (int) – 沿着哪个维度进行切分可以看成torch.cat()的逆运算过程

    c = torch.randn(7,4)

    c.chunk(chunks=4,dim=0)#,在dim=0上划分,返回的是一个元组,共分为4块

    (tensor([[ 0.0722, 0.2573, -0.2504, 1.7426],

    [-3.3098, 0.8971, 0.0274, -0.2365]]),

    tensor([[ 1.1137, 0.3401, -1.4004, 1.2823],

    [-0.5553, 0.8056, -0.1764, 0.7666]]),

    tensor([[ 1.3739, -1.4938, 1.8446, 0.4783],

    [-1.5898, -0.2520, -0.4873, 1.6098]]),

    tensor([[ 0.5421, -0.2846, 0.1441, -0.5456]]))

    torch/Tensor.clamp(input, min, max, out=None)

    功能:将tensor所有元素裁剪到指定范围[min, max]并返回

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

    c = c.clamp(3,6)#裁剪并返回

    c

    tensor([ 3, 3, 3, 4, 5, 6, 6, 6])

    torch/Tensor.sort(input, dim=None, descending=False, out=None)

    沿着指定维度排序,如果没有指定维度,默认最后一个维度,descending选择升序还是降序,返回一个元组(排序好的tensor和相应的索引)

    a = torch.randint(0,10,(2,6)).squeeze().int()

    a

    tensor([[ 0, 9, 7, 6, 3, 0],

    [ 8, 1, 8, 3, 6, 4]], dtype=torch.int32)

    a.sort(dim=0)#返回排序好的值和索引

    (tensor([[ 0, 1, 7, 3, 3, 0],

    [ 8, 9, 8, 6, 6, 4]], dtype=torch.int32),

    tensor([[ 0, 1, 0, 1, 0, 0],

    [ 1, 0, 1, 0, 1, 1]]))

    torch/Tensor.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

    返回在指定维度上k个最大的元素,默认最后一个维度,返回值是一个元组包括值和索引(values, indices) 参数:

    input (Tensor) – 输入tensor

    k (int) – k个最值元素

    dim (int) – 沿着哪个维度排许

    largest (bool) – 选取最大元素还是最小元素

    sorted (bool) – 返回元素是否有序

    torch.randn(12).topk(4)#返回topK数值和位置索引

    (tensor([ 2.0778, 1.6199, 0.8411, 0.2411]), tensor([ 0, 1, 9, 4]))

    torch.split(tensor, split_size_or_sections, dim=0)

    torch/Tensor.flatten(input, start_dim=0, end_dim=-1) → Tensor

    将一个tensor按照存储位置顺序展平

    a = torch.randn(3,3)

    print(a)

    # torch.flatten(a)

    # a.flatten()

    tensor([[-1.6724, -0.0280, 0.0100],

    [ 0.3437, 0.9472, -0.3655],

    [-0.3134, -2.6223, -0.7097]])

    torch.numel()

    返回tensor包含所有元素的数量

    torch.stack(seq, dim=0, out=None) → Tensor

    在一个新的维度上,拼接原有的tensor,注意该操作会产生新的维度,待组合的tensor要有相同的size

    参数:

    seq (sequence of Tensors) – 待拼接的tensor,要以seq形式

    dim (int) – dimension to insert. Has to be between 0 and the number of dimensions of concatenated tensors (inclusive)

    torch/Tensor.squeeze(input, dim=None, out=None) → Tensor

    去除tensor中维度=1所在的那个维度,很多时候,为了保持tensor的shape对齐会提升维度,提升一些无关紧要的1维,然而在使用的时候我们不希望这些无关紧要的维度干扰我们的操作。

    例如,如果输出shape:(A×1×B×1×D),经过squeeze后(A×B×D)注意:返回的tensor与输入共享存储空间,改变其中任何一个都会改变相应其他那个

    a = torch.arange(10).reshape(1,1,2,5)

    print('a:', a)

    b = a.squeeze()

    b += 2

    a#可以看到虽然对b操作,但是原始a的值也发生了变化

    a: tensor([[[[ 0., 1., 2., 3., 4.],

    [ 5., 6., 7., 8., 9.]]]])

    tensor([[[[ 2., 3., 4., 5., 6.],

    [ 7., 8., 9., 10., 11.]]]])

    torch/Tensor.unsqueeze(dim)

    提升一个新的维度,该dim=1,例如:(2,6)->(1,2,6)

    torch.transpose(input, dim0, dim1) → Tensor

    轴/坐标索引 交换

    torch.where(condition, x, y) → Tensor

    逐个位置元素判断,返回一个tensor可能来自源数据x或者y。

    **注意:**

    条件,x,y都必须是可广播的

    **参数:**

    condition (ByteTensor) – When True (nonzero), yield x, otherwise yield y

    x (Tensor) – values selected at indices where condition is True

    y (Tensor) – values selected at indices where condition is False

    Returns:

    返回的tensor的shape与条件,x和y都是一致的!!)

    x = torch.randn(3,2)

    y = torch.ones(3,2)

    print('x:', x)

    print('y', y)

    torch.where(x > 0 , x, y)

    x: tensor([[ 0.8968, 3.3511],

    [-0.8421, -1.1878],

    [-0.0903, 0.6168]])

    y tensor([[ 1., 1.],

    [ 1., 1.],

    [ 1., 1.]])

    tensor([[ 0.8968, 3.3511],

    [ 1.0000, 1.0000],

    [ 1.0000, 0.6168]])

    Tensor.type(torch.type)tensor数据类型转换

    Tensor.int()将数据转为int

    Tensor.long()将数据转为longInt

    Tensor.byte()将数据转换为无符号整型

    Tensor.float()将数据转换为float类型

    Tensor.double()将数据转换为double类型

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

    a.long().type()

    torch.LongTensor

    a.float().type()

    torch.FloatTensor

    a.byte().type()

    torch.ByteTensor

    Tensor.cuda(device, non_blocking=False)

    Returns a copy of this object in CUDA memory. 返回一个CUDA内存数据的副本,将输入数据存入cuda

    a = torch.arange(1200, dtype=torch.float64).cuda()

    Tensor.clone()

    Returns a copy of the self tensor. The copy has the same size and data type as self. 返回selftensor的一个拷贝,与原数据有相同的size和数据类型clone()得到的Tensor不仅拷贝了原始的value,而且会计算梯度传播信息,copy_()只拷贝数值

    a = torch.tensor([1,2,3,4,5], dtype=torch.float32, requires_grad=True)

    b = a.clone()#a经过克隆得到b,

    c = (b ** 2).mean()#

    c.backward()

    print('a_grad:', a.grad)#但是梯度传播没有因此中断

    a_grad: tensor([ 0.4000, 0.8000, 1.2000, 1.6000, 2.0000])

    Tensor.copy_(src, non_blocking=False)

    只拷贝src的数据到selftensor,并返回self,src和self可以有不同的数据类型和不同的设备上.

    参数: src (Tensor) – 源数据 non_blocking (bool) – 如果是True,copy操作跨CPU和GPU,但可能会出现异步问题

    a = torch.tensor([1,2,3,4,5], dtype=torch.float32, requires_grad=True)

    b = (a ** 2).mean()

    b.backward()

    print('a_grad:', a.grad)

    c = torch.zeros(5)

    c.copy_(a)

    print('c_grad:', c.grad)

    a_grad: tensor([ 0.4000, 0.8000, 1.2000, 1.6000, 2.0000])

    c_grad: None

    Tensor.contiguous()

    将tensor改为连续存储模式

    Tensor.fill_()内容填充

    tensor内部全部填充value元素

    Tensor.zero_()

    tensor内容全部填充0

    Tensor.normal_(mean, std, out=None)

    a = torch.randn(3,3)

    a.fill_(3)#指定内容填充

    tensor([[ 3., 3., 3.],

    [ 3., 3., 3.],

    [ 3., 3., 3.]])

    a.zero_()

    tensor([[ 0., 0., 0.],

    [ 0., 0., 0.],

    [ 0., 0., 0.]])

    a.normal_()

    tensor([[ 0.1044, -0.1353, -0.7540],

    [-0.6852, 0.2683, 0.8297],

    [ 2.8920, 0.2846, -1.1742]])

    torch生成常用矩阵

    torch.zeros(*size)

    生成全零矩阵

    torch.ones(*size)

    生成全1矩阵

    torch.eye(*size)

    生成对角矩阵,对角线元素全为1

    torch.arange(start=0, end, step=1, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

    返回指定区间,指定步长的1-D tensor

    torch.zeros(3,3)

    tensor([[ 0., 0., 0.],

    [ 0., 0., 0.],

    [ 0., 0., 0.]])

    torch.ones(3,3)

    tensor([[ 1., 1., 1.],

    [ 1., 1., 1.],

    [ 1., 1., 1.]])

    torch.eye(3,3)

    tensor([[ 1., 0., 0.],

    [ 0., 1., 0.],

    [ 0., 0., 1.]])

    torch.arange(0, 10, 2)#区间是左壁右开,不包含end

    tensor([ 0., 2., 4., 6., 8.])

    torch/Tensor.round(input, out=None) → Tensor

    对tensor内所有元素取整

    a = torch.randint(0,10,(2,2))

    a.round()

    tensor([[ 7., 5.],

    [ 1., 5.]])

    torch.randomtorch自带随机模块

    生成随机数的功能模块

    torch.random.manual_seed(seed)

    设置随机数种子

    torch.randint(low, high, size)

    返回一个服从uniform分布的int随机矩阵

    torch.randn(*sizes, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

    $\text{out}_{i} \sim \mathcal{N}(0, 1)$ 生成一个服从(0,1)标准正态分布的矩阵,传入size使用参数收集机制。

    torch.randperm(n, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False) → LongTensor

    生成一个0→n-1随机序列 参数:

    n (int) – 生成序列最大上界(不包含n)

    torch.randint(0, 10, (2,2))#使用参数收集机制

    tensor([[ 6., 9.],

    [ 3., 8.]])

    torch.randn(2,2)#使用参数收集机制,服从搞死分布

    tensor([[-0.7565, 1.2032],

    [-0.7030, 1.7259]])

    torch.randperm(4)#返回一个生成的序列

    tensor([ 0, 1, 2, 3])

    torch.arange(0,10,1).type(torch.int32)

    tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=torch.int32)

    展开全文
  • 网上的教程大多十分复杂,实际上使用logging非常简单, 三行代码就好了 我使用logging是为了方便调试, 因为输出框缓存的数量是有限的,如果把输出打印到文件中观察使用体验会好很多,因为这三行代码的功能就是为了...

    网上的教程大多十分复杂,实际上使用logging非常简单, 三行代码就好了

    我使用logging是为了方便调试, 因为输出框缓存的数量是有限的,如果把输出打印到文件中观察使用体验会好很多,因为这三行代码的功能就是为了将输出导出到某一个文件中

    配置代码如下:

    import logging
    
    logging.basicConfig(level=logging.INFO, filename='./mylog/test.log', filemode='w')

    这里首先引用了logging的包, 然后配置一下logging的基本配置

    filename表示输出文件的位置,注意这里他无法新建文件夹,意味着这里的'mylog'这个目录你需要先创建好。

    filemode='w'表示修改文件的模式,这里是指的是每一次运行文件都重新写入文件覆盖上一次运行写入的内容,更多文件的读写模式请参照: 读写模式

    这样就配置好了,然后基本使用就像print一样:

    logging.info('aaaa')

    如果想输出变量的话:使用‘f’运算符:

    aa = 1
    
    logging.info(f'aa:  {aa}')

    用大括号把待输出变量括起来就好了,最后这些输出就存储在mylog文件夹的test.log文件中。 f运算符的使用请参照:https://blog.csdn.net/lwgkzl/article/details/107695293

     

    以上

    展开全文
  • torch-0.4.1默认安装cuda版本为9.0,但是对于本机cuda-10.0版本的需要单独安装为cuda-10.0 安装torch时,不要添加官网指令的后缀的-c pytorch, 否则编译很慢 六、CUDA安装 CUDA官网(所有版本安装包列表),wget 指令...

    一、python3安装


    1. ssh之后到根目录(例如/home/shgx/software)[shgx为用户名],下载指定版本的Python3源码:

    wget https://www.python.org/ftp/python/3.5.6/Python-3.5.6.tgz

    1. 解压文件:

    tar -xvf Python-3.5.6.tgz

    1. 在根目录下(/home/shgx)创建如下路径(mkdir -p bin/Python3),使用pwd检查Python3下的路径为/home/shgx/bin/Python3
    2. 打开刚刚解压的文件目录cd /home/shgx/software/Python-3.5.6/(下面的步骤5.6.7都在此目录下执行)
    3. 进行检测

    ./configure --prefix=/home/shgx/bin/Python3

    1. 开启优化功能

    ./configure --enable-optimizations

    1. 执行指令进行编译

    make

    1. 进行安装

    make install

    1. 打开cd /home/shgx/bin/Python3/bin查看是否运行成功

    执行python3以及pip3或者/pip3

    1. 成功之后在根目录下(/home/shgx)创建软链接

    ln -s /home/shgx/bin/Python3/bin/python3 python3

    1. 以上即完成Python安装,可以在根目录下执行python3

    ./python3

    二、anaconda安装


    1.官网列有所有anaconda安装包:

    https://repo.continuum.io/archive/index.html

    2 Linux下使用wget指令获取相关安装包,指令wget + 下载链接
    3.sh指令安装时,安装指令bash + anaconda安装包(安装包应该是.sh文件),如果是在自己的用户目录下安装需要制定安装目录,不然默认安装时在/bin之下,这是系统目录,需要super权限;
    4.安装成功之后,可以通过指令conda init对环境进行激活,此时在文件~/.bashrc中一般般会出现anaconda的安装路径等相关信息;
    如果在安装完成时,并没有执行上述conda init,则需要在 ~/.bashrc 文件中自动添加相关路径,然后使用命令source ~/.bashrc激活即可;

    添加的路径信息,需要如下操作:

    首先打开文件vim ~/.bashrc #打开之后在文件末尾添加如下语句即可

    # >>> conda initialize >>>
    # !! Contents within this block are managed by 'conda init' !!
    __conda_setup="$('/home/zhangxu/software/anaconda3/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
    if [ $? -eq 0 ]; then
        eval "$__conda_setup"
    else
        if [ -f "/home/zhangxu/software/anaconda3/etc/profile.d/conda.sh" ]; then
            . "/home/zhangxu/software/anaconda3/etc/profile.d/conda.sh"
        else
            export PATH="/home/zhangxu/software/anaconda3/bin:$PATH"
        fi
    fi
    unset __conda_setup
    # <<< conda initialize <<<
    
    

    source ~/.bashrc #激活环境

    三、 anaconda 添加国内源


    1 添加conda国内镜像:

    • 清华源
    conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
    conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
    # Conda Forge
    conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
    # msys2
    conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/
    # bioconda
    conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda/
    #menpo
    conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/menpo/
    # pytorch
    conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/
    conda config --set show_channel_urls yes
    
    • 中科大源
    conda config --add channels https://mirrors.ustc.edu.cn/anaconda/pkgs/main/
    conda config --add channels https://mirrors.ustc.edu.cn/anaconda/pkgs/free/
    conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/conda-forge/
    conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/msys2/
    conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/bioconda/
    conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/menpo/
     
    conda config --set show_channel_urls yes
    

    2 删除国内源
    换回conda的默认源。查看了conda config的文档后,发现直接删除channels即可。

    conda config --remove-key channels

    3 conda本地包安装

    conda install --use-local [pak]

    4 对于pip修改国内镜像源和本地安装,具体见下:

    https://blog.csdn.net/yangwangnndd/article/details/90579809

    四、使用anaconda安装tensorflow-gpu版本


    1. 安装tensorflow时,需要tensorflow版本和cuda CUDNN版本保持一致,详细信息查看

    查看CUDA版本号: nvcc -V
    查看CUDNN版本号:cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2
    版本对应网址:https://www.tensorflow.org/install/install_sources#tested_source_configurations

    1. 下面进行安装

    python --version chan查看Python版本号
    conda create -n yangwang pip python=3.6 #yangwang 为 虚拟环境名称
    conda activate yangwang #激活虚拟环境
    conda install tensorflow-gpu==1.5.0 #安装的tensorflow版本需要和cuda cudnn相对应

    conda虚拟环境下卸载安装时:

    1.查看安装的包: conda list
    2.检查更新当前conda:conda update conda。
    3.环境中安装某个安装包:conda install -n your_env_name [package],其中[]中package为需安装的包名,your_env_name为环境名称。
    4.环境中删除某个包:conda remove --name yangwang tensorflow-estimator #yangwang为虚拟环境名称 tensorflow-estimator为安装的具体包的名称
    5.删除整个环境:conda remove -n your_env --all

    1. 测试
    conda activate yangwang / conda activate yangwang#首先激活tensorflow环境
    python  #启动python环境
    import tensorflow as tf 
    hello = tf.constant('Hello, TensorFlow!')
    sess = tf.Session()
    print (sess.run(hello))
    conda deactivte  # 退出Python后退出虚拟环境:
    

    注意:目前(2019.05.29)

    1. 不支持最新cuda版本10.1,一般使用10.0或者9.0;
    2. Python3.7支持不够完善,还有许多坑,一般使用3.6或者3.5版本;

    五、 anaconda 创建虚拟环境安装pytorch[常用]


    1. 创建虚拟环境,需要查看Python版本 :

    conda create -n pytorch python=3.6

    1. 参看 Python版本和anaconda版本以及CUDA版本,命令见上 ;
    2. 官网上根据对应机器配置安装相应的pytorch版本:

    https://pytorch.org/

    1. 安装pytorch:

    conda install pytorch torchvision cudatoolkit=9.0 cudnn

    注意:

    • torch存在安装时cuda版本和运行时版本不一致问题,二者一定要保持一致,同样不支持最新的cuda版本10.1(2019.05.29),对于cuda9.2版本支持不完善;
    • torch-0.4.1默认安装cuda版本为9.0,但是对于本机cuda-10.0版本的需要单独安装为cuda-10.0
    • 安装torch时,不要添加官网指令的后缀的-c pytorch, 否则编译很慢

    六、CUDA安装

    1. CUDA官网(所有版本安装包列表),wget 指令获取:

    https://developer.nvidia.com/cuda-toolkit-archive

    1. 安装CUDA
    2. 添加环境变量,即安装目录
    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-10.1/lib64
    export PATH=$PATH:/usr/local/cuda-10.1/bin
    export CUDA_HOME=$CUDA_HOME:/usr/local/cuda-10.1
    
    1. source ~/.bashrc
    2. 基本使用指令:
    • 显示显卡使用情况:nvidia-smi
    • 显示版本号:nvcc -V
    1. 成功
    展开全文
  • 几种最常见的机器学习的算法平台的安装,Tensorflow ,caffe 和 Torch的详细安装,我没有使用Anacanda来安装python,如果使用Anacanda来安装会省去很多步骤,因为Anacanda中已经集成了python中许多常见的库,不过...
  • 本来觉得学个tf和keras就够了,但是用了torch之后觉得真的这个框架太好用了,非常灵活可以很方便的和python语言混编,torch基本可以和cupy并列称为gpu版的numpy,文本部分有torchtext和allenlp,调包有sktorch非常...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 155
精华内容 62
关键字:

torch指南