【Tensorflow】 第五节 Ubuntu16.04LTS安装Tensorflow（CPU安装）

---

本机实验环境：

Ubuntu16.04 64 笔记本
硬件配置（涉及系统安装，配置作为参考）：
CPU： i7 - 6700HQ
GPU：GTX 960M
内存： 8 G DDR3L * 2 双通道共 16 G
SSD硬盘 ： M.2 2280 Nvme格式 固态硬盘 256G 容量
HDD硬盘 ： 5400转 机械硬盘 1T 容量

---

实验准备：

1，完成前四节
2，本机具有 Python解释器/pip/ANACONDA/PyCharm

---

实验目的

1，安装CPU版本的Tensorflow
1，运行Tensorflow案例

---

实验开始：

---

1，安装虚拟环境Virtualenv

打开终端输入：

sudo apt-get install python-virtualenv

使用包管理器下载Virtualenv
安装成功后创建Virtualenv虚拟环境
Python2.X输入以下代码

virtualenv --system-site-packages targetDirectory

Python3.X输入以下代码

virtualenv --system-site-packages -p python3 targetDirectory

其中的targetDirectory是目标地址，我这里替换为

~/tensorflow

创建虚拟环境成功后就需要激活虚拟环境

source ~/tensorflow/bin/activate

等待提示符改变，若显示(tensorflow)$
则表示进入虚拟环境。

先不要退出虚拟环境我们在虚拟环境中安装tensorflow

---

2，安装Tensorflow（CPU版本)

接着上面的虚拟机终端，在虚拟环境中输入以下命令，这里还是有两个版本，选择对应的版本进行输入。

Python2.X输入

pip install --upgrade tensorflow

Python3.X输入

pip3 install --upgrade tensorflow

等待安装完成后就完成了。

---

3，跑tensorflow案例程序

这里提供一个Tensorflow的案例程序，是识别手写数字的程序。
需要先下载数据集

数据集下载
数据集组成：
train-images-idx3-ubyte.gz: training set images (9912422 bytes)
train-labels-idx1-ubyte.gz: training set labels (28881 bytes)
t10k-images-idx3-ubyte.gz: test set images (1648877 bytes)
t10k-labels-idx1-ubyte.gz: test set labels (4542 bytes)

下载完成后先都可以放在桌面上，等下需要移动到data文件夹。
这里提供程序算法Python文件：

//fc_feed.py

# coding:utf-8

import tensorflow as tf
import argparse
import sys
import math

from tensorflow.examples.tutorials.mnist import input_data

image_size = 28
FLAGS = None
NUM_CLASSES = 10
keep_p = tf.constant(0.5, dtype=tf.float32)


def train():
    # 加载数据集：训练、验证和测试数据集
    data_sets = input_data.read_data_sets(FLAGS.input_data_dir, FLAGS.fake_data)
    train_data = data_sets.train
    valid_data = data_sets.validation
    test_data = data_sets.test

    graph = tf.Graph()
    with graph.as_default():
        x_placeholder = tf.placeholder(tf.float32, shape=(None, image_size*image_size), name='input_x')
        y_placeholder = tf.placeholder(tf.float32, shape=(None), name='input_y')

        weights = {
            'h1': tf.Variable(tf.truncated_normal([image_size*image_size, FLAGS.hidden1],
                                                stddev=1.0 / math.sqrt(float(image_size*image_size))), name='h1/weights'),
            'h2': tf.Variable(tf.truncated_normal([FLAGS.hidden1, FLAGS.hidden2],
                                                 stddev=1.0 / math.sqrt(float(FLAGS.hidden1))), name='h2/weights'),
            'out': tf.Variable(tf.truncated_normal([FLAGS.hidden2, NUM_CLASSES],
                                                 stddev=1.0 / math.sqrt(float(FLAGS.hidden2))), name='out/weights')
        }

        biases = {
            'h1': tf.Variable(tf.zeros([FLAGS.hidden1]), name='h1/biases'),
            'h2': tf.Variable(tf.zeros([FLAGS.hidden2]), name='h2/biases'),
            'out': tf.Variable(tf.zeros([NUM_CLASSES]), name='out/biases')
        }

        hidden1 = tf.nn.relu(tf.matmul(x_placeholder, weights['h1']) + biases['h1'])
        #hidden1 = tf.nn.dropout(hidden1, keep_prob=keep_p)
        hidden2 = tf.nn.relu(tf.matmul(hidden1, weights['h2']) + biases['h2'])
        #hidden2 = tf.nn.dropout(hidden2, keep_prob=keep_p)
        logits = tf.matmul(hidden2, weights['out']) + biases['out']

        labels = tf.to_int64(y_placeholder)
        cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')
        loss = tf.reduce_mean(cross_entropy, name='xentropy_mean')
        #  loss = tf.reduce_mean(tf.nn. sparse_softmax_cross_entropy_with_logits(labels=y_placeholder, logits=output)
        #                       + 0.5 * 0.01 * tf.nn.l2_loss(weights['h1'])
        #                       + 0.5 * 0.01 * tf.nn.l2_loss(weights['h2'])
        #                       + 0.5 * 0.01 * tf.nn.l2_loss(weights['out']))

        correct = tf.nn.in_top_k(logits, labels, 1)
        eval_correct = tf.reduce_sum(tf.cast(correct, tf.int32))

        optimizer = tf.train.GradientDescentOptimizer(FLAGS.learning_rate)
        global_step = tf.Variable(0, name='global_step', trainable=False)
        train_op = optimizer.minimize(loss, global_step=global_step)

    with tf.Session(graph=graph) as sess:
        sess.run(tf.global_variables_initializer())
        for step in xrange(FLAGS.max_steps):
            images, labels = train_data.next_batch(batch_size=FLAGS.batch_size)
            _, loss_value = sess.run([train_op, loss],
                                     feed_dict={x_placeholder: images,
                                                y_placeholder: labels})
            del images, labels

            if step % 100 == 0:
                print('Step %d: loss = %.2f' % (step, loss_value))

            if (step + 1) % 1000 == 0 or (step + 1) == FLAGS.max_steps:
                # Evaluate against the validation set.
                print('Validation Data Eval:')
                true_count = sess.run(eval_correct, feed_dict={x_placeholder: valid_data.images,
                                                               y_placeholder: valid_data.labels})
                num_examples = valid_data.num_examples
                precision = float(true_count) / num_examples
                print('  Num examples: %d  Num correct: %d  Precision @ 1: %0.04f' %
                      (num_examples, true_count, precision))

                # Evaluate against the test set.
                print('Test Data Eval:')
                true_count = sess.run(eval_correct, feed_dict={x_placeholder: test_data.images,
                                                               y_placeholder: test_data.labels})
                num_examples = test_data.num_examples
                precision = float(true_count) / num_examples
                print('  Num examples: %d  Num correct: %d  Precision @ 1: %0.04f' %
                      (num_examples, true_count, precision))


def main(_):
    if tf.gfile.Exists(FLAGS.log_dir):
        tf.gfile.DeleteRecursively(FLAGS.log_dir)
    tf.gfile.MakeDirs(FLAGS.log_dir)
    train()


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--learning_rate',
        type=float,
        default=0.01,
        help='Initial learning rate.'
    )
    parser.add_argument(
        '--max_steps',
        type=int,
        default=2000,
        help='Number of steps to run trainer.'
    )
    parser.add_argument(
        '--hidden1',
        type=int,
        default=128,
        help='Number of units in hidden layer 1.'
    )
    parser.add_argument(
        '--hidden2',
        type=int,
        default=32,
        help='Number of units in hidden layer 2.'
    )
    parser.add_argument(
        '--batch_size',
        type=int,
        default=100,
        help='Batch size.  Must divide evenly into the dataset sizes.'
    )
    parser.add_argument(
        '--input_data_dir',
        type=str,
        default='data',
        help='Directory to put the input data.'
    )
    parser.add_argument(
        '--log_dir',
        type=str,
        default='log',
        help='Directory to put the log data.'
    )
    parser.add_argument(
        '--model_dir',
        type=str,
        default='models',
        help='Directory to put the log data.'
    )
    parser.add_argument(
        '--fake_data',
        default=False,
        help='If true, uses fake data for unit testing.',
        action='store_true'
    )

    FLAGS, unparsed = parser.parse_known_args()
    tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

在PyCharm中打开该程序，

提示要配置Oython编译器，点击右边的链接-Configure Python Interpreter

选择添加本地路径解释器
选择自己的tensorflow文件夹bin中的python编译器


等待包加载完毕，点击OK

运行该程序，会报错，不用管。回到程序根部目录，会发现自动生成data和log文件夹，我们把之前手动下载的数据集都扔到data文件夹中。

再次进入PyCharm，运行程序。
若控制台输出如下，则完成本次实验，案例程序跑成功。

---