import os
import tensorflow as tf
os.environ[‘TF_CPP_MIN_LOG_LEVEL‘] = ‘2‘

# 使用TensorFlow输出Hello

# 创建一个常量操作( Constant op )
# 这个 op 会被作为一个节点( node )添加到默认计算图上.
#
# 该构造函数返回的值就是常量节点(Constant op)的输出.
hello = tf.constant(‘Hello, TensorFlow!‘)

# 启动TensorFlow会话
sess = tf.Session()


# 运行 hello 节点
print(sess.run(hello))
‘‘‘
TensorFlow library 的基本操作.
‘‘‘
import os
import tensorflow as tf
os.environ[‘TF_CPP_MIN_LOG_LEVEL‘] = ‘2‘

# 基本常量操作
# T构造函数返回的值就是常量节点(Constant op)的输出.
a = tf.constant(2)
b = tf.constant(3)

# 启动默认的计算图
with tf.Session() as sess:
    print("a=2, b=3")
    print("常量节点相加: %i" % sess.run(a+b))
    print("常量节点相乘: %i" % sess.run(a*b))

# 使用变量(variable)作为计算图的输入
# 构造函数返回的值代表了Variable op的输出 (session运行的时候，为session提供输入)
# tf Graph input
a = tf.placeholder(tf.int16)
b = tf.placeholder(tf.int16)

# 定义一些操作
add = tf.add(a, b)
mul = tf.multiply(a, b)

# 启动默认会话
with tf.Session() as sess:
    # 把运行每一个操作，把变量输入进去
    print("变量相加: %i" % sess.run(add, feed_dict={a: 2, b: 3}))
    print("变量相乘: %i" % sess.run(mul, feed_dict={a: 2, b: 3}))


# 矩阵相乘(Matrix Multiplication)
# 创建一个 Constant op ，产生 1x2 matrix.
# 该op会作为一个节点被加入到默认的计算图
# 构造器返回的值 代表了Constant op的输出
matrix1 = tf.constant([[3., 3.]])
# 创建另一个 Constant op 产生  2x1 矩阵.
matrix2 = tf.constant([[2.],[2.]])
# 创建一个 Matmul op 以 ‘matrix1‘ 和 ‘matrix2‘ 作为输入.
# 返回的值, ‘product‘, 表达了矩阵相乘的结果
product = tf.matmul(matrix1, matrix2)
# 为了运行 matmul op 我们调用 session 的 ‘run()‘ 方法, 传入 ‘product‘
# ‘product’表达了 matmul op的输出. 这表明我们想要取回(fetch back)matmul op的输出
# op 需要的所有输入都会由session自动运行. 某些过程可以自动并行执行
#
# 调用 ‘run(product)‘ 就会引起计算图上三个节点的执行：2个 constants 和一个 matmul.
# ‘product’op 的输出会返回到 ‘result‘：一个 numpy `ndarray` 对象.
with tf.Session() as sess:
    result = sess.run(product)
    print(‘矩阵相乘的结果：‘, result)
    # ==> [[ 12.]]

#保存计算图
writer = tf.summary.FileWriter(logdir=‘logs‘, graph=tf.get_default_graph())
writer.flush()

import os  
os.environ["TF_CPP_MIN_LOG_LEVEL"]=‘1‘ # 这是默认的显示等级，显示所有信息  
os.environ["TF_CPP_MIN_LOG_LEVEL"]=‘2‘ # 只显示 warning 和 Error   
os.environ["TF_CPP_MIN_LOG_LEVEL"]=‘3‘ # 只显示 Error

import numpy as np
import os
import tensorflow as tf
os.environ[‘TF_CPP_MIN_LOG_LEVEL‘] = ‘2‘

# 导入MNIST数据集
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("mnist_data/", one_hot=True)

# 我们对MNIST数据集做一个数量限制，
Xtrain, Ytrain = mnist.train.next_batch(5000) #5000 用于训练(nn candidates)
Xtest, Ytest = mnist.test.next_batch(200) #200 用于测试
print(‘Xtrain.shape: ‘, Xtrain.shape, ‘, Xtest.shape: ‘,Xtest.shape)
print(‘Ytrain.shape: ‘, Ytrain.shape, ‘, Ytest.shape: ‘,Ytest.shape)

# 计算图输入占位符
xtrain = tf.placeholder("float", [None, 784])
xtest = tf.placeholder("float", [784])

# 使用L1距离进行最近邻计算
# 计算L1距离
distance = tf.reduce_sum(tf.abs(tf.add(xtrain, tf.negative(xtest))), axis=1)
# 预测: 获得最小距离的索引 (根据最近邻的类标签进行判断)
pred = tf.arg_min(distance, 0)
#评估：判断给定的一条测试样本是否预测正确

# 初始化节点
init = tf.global_variables_initializer()

#最近邻分类器的准确率
accuracy = 0.

# 启动会话
with tf.Session() as sess:
    sess.run(init)
    Ntest = len(Xtest)  #测试样本的数量
    # 在测试集上进行循环
    for i in range(Ntest):
        # 获取当前测试样本的最近邻
        nn_index = sess.run(pred, feed_dict={xtrain: Xtrain, xtest: Xtest[i, :]})
        # 获得最近邻预测标签，然后与真实的类标签比较
        pred_class_label = np.argmax(Ytrain[nn_index])
        true_class_label = np.argmax(Ytest[i])
        print("Test", i, "Predicted Class Label:", pred_class_label,
              "True Class Label:", true_class_label)
        # 计算准确率
        if pred_class_label == true_class_label:
            accuracy += 1
    print("Done!")
    accuracy /= Ntest
    print("Accuracy:", accuracy)

reduce_sum(
    input_tensor,
    axis=None,
    keep_dims=False,
    name=None,
    reduction_indices=None
)

tf.argmin
argmin(
    input,
    axis=None,
    name=None,
    dimension=None,
    output_type=tf.int64
)