01 最全TensorFlow-gpu-1.8/1.3+Ubuntu18.04+CUDA9.0+cudnn7.0+Anaconda+pycharm+libcublas.so.9.0缺少解决办法

安装说明

[补充]
目前安装tensorflow-gpu不需要这么复杂了，只需要安装anaconda,记得添加进环境路径，然后新建一个环境，激活它，之后conda install tensorflow-gpu就可以自动安装好了。具体的代码如下：

conda create -n tf_env python=3.6 # 创建一个独立的环境(推荐)
source activate tf_env # 激活环境，否则包会安装到base环境里
conda install tensorflow-gpu # 可能速度比较慢，可以换国内源，但是好像国内源比较旧版本
# 如果换过国内源发现版本比较旧的话，你先看下原始的会给你安装什么版本
# 清华镜像5分钟同步一次，但是索引比较旧. 假设你换好了国内源，可以通过：
conda install tensorflow-gpu==1.12(可能不大一样)  # 后面那个是版本号，你看下原始的会给你装多少，复制过来
# cudnn、cuda全部给你安装好了，现在很多包的依赖项conda 都会帮你安装好，实时更新conda就好

大概弄了3天吧，吃第一口螃蟹真的不容易.说一下怎么安装吧，有些操作我也不确定(记不住了，尝试了太多了)，大家遇到情况可能不一样，有问题可以咨询我，但是TensorFlow安装步骤是一样的，先说下安装顺序：

1. NVIDIA驱动
2. CUDA9.0
3. cudnn7.0
4. Anaconda
5. TensorFlow-gpu1.8/1.3
6. pycharm

如果不需要TensorFlow1.8版本的可以跳过1.2.3步骤，直接安装Anaconda，然后直接进行5.6步骤.

机器环境

系统 Ubuntu18.04

CPU E3-1231V3

TensorFlow 1.8

说明一下，双显卡怎么安装Ubuntu18.04可以自行百度下，接下来如果安装TensorFlow我也没有测试过，因为本人至今没有给笔记本(Intel核心和NVIDIA)装上Ubuntu18.04，如果是台式机的话可以选择拔下独立显卡，安装好系统后再安装NVIDIA并安装驱动？因为比较麻烦，为了避坑，特意选了没有核显的E3-1231V3.可以自行百度.其主要区别在于Ubuntu和NVIDIA驱动安装.

1.NVIDIA驱动

ubuntu自带了nvidia驱动，但是它没有安装完整，不能在终端查看nvidia-smi，在之后的CUDA编译测试里面也会出现问题，因此需要重新安装.重新安装的方式很简单，在桌面打开终端，输入：

sudo apt install nvidia-utils-390
sudo ubuntu-drivers autoinstall

输入完这两条命令之后，在终端输入nvidia-smi能够看到信息则表示成功重新安装了驱动.需要重启机器.

2.CUDA9.0

降级gcc

因为Ubuntu18.04默认gcc7.0，而CUDA9.0只支持gcc6.0及以下版本，因此需要降级，我选择降级的是5.5.

首先查看自己的版本:gcc --version，一般显示7.0，因此降级版本并激活

在终端输入

sudo apt-get install gcc-5 g++-5 
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 50
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-5 50

这时候再输入gcc --version，如果显示是5.5版本则OK.如果按照我的做法没有降级的小伙伴，一定要百度怎么降级.(我参考了很多，也是出现一些没法降级的情况，如果没有降级不保证会不会出现其他情况)

依赖库

终端里输入：

sudo apt-get install freeglut3-dev build-essential libx11-dev libxmu-dev libxi-dev libgl1-mesa-glx libglu1-mesa libglu1-mesa-dev

成功安装完依赖库

安装

必须是CUDA9.0，百度搜索一下，下载地址，下载到downloads里面

在download里面打开终端，输入：sudo sh cuda_9.0.176_384.81_linux.run --override,总所有设置都设置默认，也就是输入y，第一个提示输入accept,它让你安装显卡驱动的时候用输n,因为之前已经安装过了.

安装完整之后是这样的，因为没有安装它提示的驱动，所以提示安装不完整:

添加环境变量，使其生效

这里到home里面双击打开.bashrc文件（看不见ctrl+h查看隐藏文件），添加下面这几个命令就好了.（我添加了很多，不确定是哪一条生效，照做就OK，经测试没有问题）

export CUDA_HOME=/usr/local/cuda-9.0
export LD_LIBRARY_PATH=/usr/local/cuda-9.0/lib64:/usr/local/cuda-9.0/extras/CUPTI/lib64:$LD_LIBRARY_PATHs
export PATH=/usr/local/cuda-9.0/bin:$PATH
export LD_LIBRARY_PATH="/usr/local/cuda-9.0/lib64:/usr/local/cuda-9.0/extras/CUPTI/lib64:/usr/local/cuda-9.0/lib64:/usr/local/cuda-9.0/lib64"

之后让其立即生效,在主目录打开终端输入source .bashrc.

3.cudnn7.0

我们还要安装cudnn7.0，这个比较简单，可以参考cudnn安装，我是通过deb安装的，千万注意版本，一定对版本安装，下面是下载地址

选择for Linux或者Deb包都OK，好吧，为了大家我新开了台电脑又安装了一遍，下载cuDNN v7.05 Library for Linux,下载完成后打开终端，其实并没有那么复杂，输入:

tar -zxvf cudnn-9.0-linux-x64-v7.tgz
sudo cp cuda/include/cudnn.h /usr/local/cuda/include/
sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64/ -d
sudo chmod a+r /usr/local/cuda/include/cudnn.h
sudo chmod a+r /usr/local/cuda/lib64/libcudnn*

我们到桌面重新打开个命令行，cd /,cd usr/local，最后输入ls -l，如果显示有cuda和cuda9.0的文件夹，如图所示:

确保有cuda和cuda-9.0文件，这样就安装成功了.

4.Anaconda

安装

下载地址

下载.sh文件，输入命令：bash An***.sh,具体看你哪个版本，根据提示操作即可.遇到选项都选yes，要安装c++库也同意.参考安装网站，这里有两个要注意的.

1.不要用sudo命令，会造成anaconda文件夹其他应用无法修改

2.一定要添加环境变量还有提示的库安装，如果自己重新添加的话会很麻烦.

安装完之后，需要用命令行启动anaconda-navigator即可，打开Spyder，如果能够打开测试一下安装就OK了.(没有快捷方式，只能这样打开)(我是安装好TensorFlow 的，因此大家拿普通python文件测试即可，测试是否安装好Anaconda)

换国内源

墙太高翻不动，因此要换国内源.

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/

conda config --set show_channel_urls yes

5.1TensorFlow1.8安装

TensorFlow1.8的话需要自己安装，conda不会自动安装CUDA8.0、cudnn6.0这些配置(未来可能会支持自动安装CUDA9…0、cudnn7.0)，拭目以待.

1. 打开桌面终端，输入source activate base，base是默认的Anaconda环境，建议自己新建一个环境再激活它.通过命令行输入anaconda-navigator启动anaconda图形化界面来创建.创建完成后source activate tensorflow，例如我创建的是tensorflow。
2. 搜索各个版本.anaconda search -t conda tensorflow
   
   这里xxbandy123/tensorflow代表CPU版本，TensorFLow版本1.6，支持linux-64，py2.7之类的信息，这里我们不用管，因为有个TensorFlow源仓库始终保持最新版本，并且兼容win64和linux64.
3. 输入命令 anaconda show aaronzs/tensorflow-gpu，然后照着提示，比如我的提示是conda install --channel https://conda.anaconda.org/aaronzs tensorflow-gpu安装.
4. 如果是安装在其他环境下，则直接命令行打开python解释器默认是anacondabase环境下的解释器，直接CMD测试不会成功.

5.2TensorFlow1.3安装

如果不嫌弃版本太低，直接用conda环境安装即可，所有依赖的东西都可以一口气解决，当然包括驱动、CUDA、cudnn.

1. 终端输入source activate base,base是要安装的环境
2. conda install tensorflow-gpu，它会自动帮你安装上Tensorflow-gpu1.3版本

测试

如果安装好了TensorFlow，可以测试一下，这里我给一个测试文件.复制保存成.py之后，在该文件目录打开终端，输入python **.py直接运行，如果没有报错的话，就说明TensorFlow安装成功了.会输抽出准确率、保存训练日志、完成时间等,GTX960在GPU训练情况下在40秒左右，可以拿来参考.

测试文件

import argparse
import sys
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import time

# 1.2  (1).(2)  A.B
# 一步一步来，否则最后很难找错误
NUM_CLASSES = 10
IMAGE_SIZE = 28
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE

# 1. 添加全局变量
FLAGS = None

# 这个初始化只是方便一下，抓住主线
def weight_variable(shape):
    '''权重初始化，返回默认为形状为shape标准差为0.1的截断正态分布矩阵.

    :param shape: 权重矩阵的形状.
    :return: 初始化后的权重矩阵
    '''
    initial_Weight = tf.Variable(tf.truncated_normal(shape, stddev=0.1))
    return initial_Weight


def bias_variable(shape):
    '''偏置初始化，默认初始化为全为1，形状为shape的偏置矩阵

    :param shape: 偏置矩阵的shape
    :return: 初始化后的偏置矩阵
    '''
    initial_bias = tf.Variable(tf.constant(0.1, shape=shape))
    return initial_bias

# A. summary.scalar一下
# B. merge_all成summaries节点
# C. sess.run(节点)成str
# D. 将str add进事件，并且附上步数
# E. 记录训练汇总信息

# A1.对一个张量进行全面的汇总（均值，标准差，最大最小值，直方图）写一个函数
def variable_summaries(var):
    with tf.name_scope('summaries'):
        mean = tf.reduce_mean(var)
        tf.summary.scalar('mean', mean)
        with tf.name_scope('stddev'):
            # 标准差计算公式
            stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
            tf.summary.scalar('stddev', stddev)
            tf.summary.scalar('max', tf.reduce_max(var))
            tf.summary.scalar('min', tf.reduce_min(var))
            tf.summary.histogram('histogram', var)


# 神经元个数一般讲该神经层输出的数目.
def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu):
    '''它在内部做了一个矩阵乘法，偏置加法，然后利用relu进行非线性输出映射.添加了每一层的name_scope

    和汇总节点

    :param input_tensor: 输入Tensor,即X
    :param input_dim: 输入的维度
    :param output_dim: 神经元的数目
    :param layer_name: 神经层的名字
    :param act: 激活函数,默认tf.nn.relu
    :return: 该神经层节点
    '''
    with tf.name_scope(layer_name):
        with tf.name_scope('Weights'):
            weights = weight_variable([input_dim, output_dim])
            # A2.scalar一下
            variable_summaries(weights)
        with tf.name_scope('biases'):
            biases = bias_variable([output_dim])
            # A2.scalar一下
            variable_summaries(biases)
        with tf.name_scope('Wx_plus_b'):
            peractivate = tf.matmul(input_tensor, weights) + biases
            tf.summary.histogram('pre_activations', peractivate)
        activations = act(peractivate)
        tf.summary.histogram('activations', activations)
    # 最后换行return还是怎样ruturn是看逻辑的，不一定需要在with里面return
    return activations


# 3.构造计算图，之后启动训练过程《《主函数》》
def train():
    # (1) 占位符
    # (7).声明一个交互式会话
    # (6).导入数据，喂数据.也写在计算图中，因为是往占位符中喂数据，所以要在占位符之后
    mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True, fake_data=FLAGS.fake_data)
    sess = tf.InteractiveSession()
    with tf.name_scope('input'):
        x = tf.placeholder(tf.float32,[None, IMAGE_PIXELS], name='X_input')
        y_true = tf.placeholder(tf.float32,[None, NUM_CLASSES], name='Y_input')
    # <<图片
    with  tf.name_scope('input_reshape'):
        image_shape_input = tf.reshape(x,[-1, 28, 28, 1]) # batch_size
        tf.summary.image('input',image_shape_input,10) #放10个图像
    # (2) Inference00.mnist_with_summaries.py
    hidden1 = nn_layer(x, IMAGE_PIXELS, FLAGS.hidden1, 'layer1')

    with tf.name_scope('dropout'):
        # 要放入计算图中看的，要用TF函数.想要不断手动调整的，更改的用placeholder.数据也用placeholder传入
        # 如果用常量，就不方便更改dropout，不方便汇总看后面代码
        # 训练和测试的时候，这个keep率不同。因此需要占位符
        keep_prob = tf.placeholder(tf.float32)
        tf.summary.scalar('dropout_keep_probability', keep_prob)
        # A1 tf.summary.scalar('dropout_keep_probability',keep_prob)
        dropped = tf.nn.dropout(hidden1, keep_prob)

    logits = nn_layer(dropped, FLAGS.hidden1, NUM_CLASSES, 'layer2', act=tf.identity)# tf.identity 什么都不做

    # (3) Loss 定义损失节点，先让图跑起来，再决定要查看什么数据
    with tf.name_scope('cross_entropy'):
        diff = tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=logits)
        with tf.name_scope('total'):
            cross_entropy = tf.reduce_mean(diff)

    # A1
    tf.summary.scalar('cross_entropy', cross_entropy)

    # (4) 定义训练节点
    with tf.name_scope('train'):
        optimizer = tf.train.AdamOptimizer(learning_rate=FLAGS.learning_rate)
        train_step = optimizer.minimize(cross_entropy)

    # (5) 定义评估节点
    with tf.name_scope('accuracy'):
        # 当前批次样本的预测正确性
        with tf.name_scope('correct_prediction'):
            correct_prediction = tf.equal(tf.argmax(logits,1), tf.argmax(y_true, 1))#返回的是布尔类型
        with tf.name_scope('accuracy'):
            accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    def feed_dict(train):
        '''
        喂数据
        :param train:True or False
        :return: 训练集/测试集合
        '''
        if train or FLAGS.fake_data:  # 这里只是作为提示，加上FLAGS.fake_data
            # True/false
            xs, ys = mnist.train.next_batch(100, fake_data=FLAGS.fake_data)
            k = FLAGS.dropout  # k=0.9
        else:  # 否则是测试集
            xs, ys = mnist.test.images, mnist.test.labels
            k = 1.0
        return {x: xs, y_true: ys, keep_prob: k}  # 喂数据要字典形式传入


    # B1.merge_all成summaries节点
    merged = tf.summary.merge_all()
    # B2.写入测试日志节点(计算图中的程序不一定顺序运行，需要调用，所以这里不需要条件判断，会各自存在计算图中)
    train_writer = tf.summary.FileWriter(FLAGS.log_dir + '/train', sess.graph)
    # B2.写入测试日志节点(因为前后先后调用，前面sess.graph已经打开，所以这里不需要sess.graph）
    test_writer = tf.summary.FileWriter(FLAGS.log_dir + '/test')
    # (8).初始化所有变量
    tf.global_variables_initializer().run()
    #  写入计算图（喂测试0
    # wirter = tf.summary.FileWriter(logdir=FLAGS.log_dir,graph=tf.get_default_graph())  (这里为了演示前面的过程，保证计算图正确)
    # wirter.close()


    # 4.开启训练模式
    # 首先每次训练，将训练信息记录进summary,隔10步记录一次测试信息.
    # 在余下的9步里面，隔100步跟踪一次各个权重.添加进训练信息.
    # 剩下的99步，

    time_start = time.time()
    for step in range(FLAGS.max_steps):
        # (1）利用feed_dict()函数喂数据
        # C1.sess.run(节点)成str
        # D. 将str add进训练事件，分别写入，并且附上步数.step
        # 是add进去的.因为训练是每一步都进行的，喂的数据是训练数据,同样要打开merged文件.
        if step % 10 == 0:
            summary, acc = sess.run([merged, accuracy], feed_dict(False))
            test_writer.add_summary(summary, global_step=step)
            print('第%s，准确率=%s'%(step,acc))
       # E.1记录训练汇总信息
        else:
            if step % 100 ==99: # 每隔100步跟踪一次数据
                # A.run_optins-tf.RunOptions
                # B.run_metadat-tf.RunMetadata()
                # C.sess.run  options/run
                # D.add_run_metadata
                run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
                run_metadata = tf.RunMetadata()
                summary, _ = sess.run([merged, train_step],
                                      feed_dict=feed_dict(True),
                                      options=run_options,
                                      run_metadata=run_metadata)
                train_writer.add_run_metadata(run_metadata, 'step%03d' % step)
                train_writer.add_summary(summary, step)
            else:
                summary, _ = sess.run([merged, train_step],feed_dict=feed_dict(True))
                train_writer.add_summary(summary,step)

    # 最后要关闭FileWriter.Python关闭文件的位置很重要.
    time_end = time.time()
    print('totally cost', time_end - time_start)
    train_writer.close()
    test_writer.close()


# 2.运行主函数main，创建日志文件（log_dir)，启动训练过程
def main(_):
    if tf.gfile.Exists(FLAGS.log_dir):
        # tf.gfile:tensorflow的文件管理模块
        tf.gfile.DeleteRecursively(FLAGS.log_dir)
    tf.gfile.MakeDirs(FLAGS.log_dir)
    train()


# 1 这里是开始读程序的地方
if __name__ == '__main__':
    # 1.1 实例化一个全局解析器
    parser = argparse.ArgumentParser()
    # 1.2 往全局解析器里面添加东西
    # 是否用假数据
    parser.add_argument('--fake_data', nargs='?', const=True, type=bool,
                        default=False,
                        help='If true, uses fake data for unit testing.')
    parser.add_argument('--max_steps', type=int, default=1000,
                        help='Number of steps to run trainer.')
    parser.add_argument('--learning_rate', type=float, default=0.001,
                        help='Initial learning rate')
    parser.add_argument('--hidden1', type=int, default=500,
                        help='第一个隐藏层的神经元个数')
    # dropout 为防止过拟合
    parser.add_argument('--dropout', type=float, default=0.9,
                        help='Keep probability for training dropout.')
    parser.add_argument('--data_dir', type=str,
                        default='MNIST_data/',
                        help='Directory for storing input data')
    parser.add_argument('--log_dir', type=str,
                        default='logs/mnist_with_summaries',
                        help='Summaries log directory')
    # 1.3 将这些参数解析到全局变量FLAGS中
    FLAGS, unparsed = parser.parse_known_args()
    # 1.4 运行某个程序，以某个全局解析器的参数
    tf.app.run(main=main, argv=[sys.argv[0]]+unparsed)

错误调试

1. 缺少libcublas.so文件，检查一下.bashrc文件，是否source ~/.bashrc,最后的样子要和我之前的图一样.

2. python不是Anaconda版本，这个也是检查.bashrc，是否添加这一句，注意ts是我的用户名，请修改成自己的.

   export PATH="/home/ts/anaconda3/bin:$PATH"
   

3. 有些.bashr路径需要检查一下，是否是你自己的文件路径，不同电脑位置可能会有不同.

4. 检查到底哪一步出错，CUDA9.0、cudnn(最容易出错的地方)还是什么，自己百度一下

5. 如果解决不了，就安装TensorFlow-gpu-1.3版本，或者安装Windows下的TensorFlow

6. 如果还是不行，其实cpu版本也蛮快的(至少比脑子转的快)，其实是真的难装，身为一个资深掏粪男孩，Windows平台上装了3天，Ubuntu18.04装了大概4天(在有WINDOWS平台安装经验基础上)

6.安装pycharm

pycharm版本说明

如果前面都安装好的话，就可以装pycharm了.这里我用的是2018专业版，如果有校园邮箱,也就是edu.cn结尾的邮箱的同学可以免费申请pycharm，可以自己百度一下，免费用一年，第二年再激活一下还可以再用，并且可以在好几台电脑上使用.据说毕业了就不能用了，但问题不大.如果不是校内学生或者老师的话，建议购买(ttmgl)专业版，也可以使用社区版或者网上搜破解版.(pycharm还是挺良心的对科研人员，因此我个人不推荐).

安装

我们去官网下载下来，pycharm-professional-2018.1.3.tar.gz，双击打开，解压到要安装的目录,到该目录bin下，打开终端输入sh pycharm.sh就可以打开了，与平时一样正常使用.(不要在ubuntu的software里面安装，因为后面我们要编辑pycharm启动文件，否则pycharm里面不能运行tensorflow)

然而我们发现，在终端里面测试文件可以被正常运行，pycharm里面又不能运行了，解决办法如下：

pycharm里面缺少libcublas.so.9.0解决办法

这里有两个解决办法，这里主要的原因是pycharm没有读取.bashrc文件的权限，因此需要自己手动设置.

1. 手动设置

2. 修改pycharm.sh

   双击文件pycharm.sh，在IFS="$(printf '\n\t')"后面按Enter空出一行，然后添加LD_LIBRARY_PATH="/usr/local/cuda/lib64:/usr/local/cuda-9.0/lib64:/usr/local/cuda-9.0/extras/CUPTI/lib64"
   

需要关闭再重新打开pycharm，sh pycharm.sh，点击运行，没有报错(使用的是View下的sci模式，看数据会方便一点):
每次都要来这里点开太麻烦了，我们可以讲pycharm.sh添加到系统环境中，可以自行百度。
查看tensorboard，在pycharm里面的终端，输入tensorboard --logdir 事件文件夹的位置,可以看到:

双击点开端口,没有问题(这里要用谷歌浏览器，自行百度搜索谷歌浏览器):