TensorFlow教程（二）

training_set = tf.contrib.learn.datasets.base.load_csv_with_header(
    filename=IRIS_TRAINING, target_dtype=np.int, features_dtype=np.float32)
test_set = tf.contrib.learn.datasets.base.load_csv_with_header(
    filename=IRIS_TEST, target_dtype=np.int, features_dtype=np.float32)
...

classifier.fit(x=training_set.data,
               y=training_set.target,
               steps=2000)

def my_input_fn():

    # 在这里预处理您的数据

    # ... return 1) 包含key：特征名-value：特征量的张量 的dict
    # 2) 特征对应的标签的张量类型
    return feature_cols, labels

feature_column_data = [1, 2.4, 0, 9.9, 3, 120]
feature_tensor = tf.constant(feature_column_data)
print(feature_tensor)

sparse_tensor = tf.SparseTensor(indices=[[0,1], [2,4]],
                                values=[6, 0.5],
                                dense_shape=[3, 5])
'''
[[0, 6, 0, 0, 0]
 [0, 0, 0, 0, 0]
 [0, 0, 0, 0, 0.5]]
'''

# 方式1：包装函数
def my_input_function_training_set():
  return my_input_function(training_set)

classifier.fit(input_fn=my_input_fn_training_set, steps=2000)

# 方式2：偏函数
classifier.fit(input_fn=functools.partial(my_input_function,
                                          data_set=training_set), steps=2000)

# 方式3：lambda
classifier.fit(input_fn=lambda: my_input_fn(training_set), steps=2000)

import itertools

import pandas as pd #这里使用了pandas库，pip install pandas安装下
import tensorflow as tf

tf.logging.set_verbosity(tf.logging.INFO) #开启INFO级别日志

#定义cvs文件的列名，以便于提取数据
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
           "dis", "tax", "ptratio", "medv"]
FEATURES = ["crim", "zn", "indus", "nox", "rm",
            "age", "dis", "tax", "ptratio"]
LABEL = "medv"

#读取数据
training_set = pd.read_csv("boston_train.csv", skipinitialspace=True,
                           skiprows=1, names=COLUMNS)
test_set = pd.read_csv("boston_test.csv", skipinitialspace=True,
                       skiprows=1, names=COLUMNS)
prediction_set = pd.read_csv("boston_predict.csv", skipinitialspace=True,
                             skiprows=1, names=COLUMNS)
print("测试样例")
print(type(training_set), len(training_set))
print(training_set)

#定义输入函数
def input_fn(data_set):
  feature_cols = {k: tf.constant(data_set[k].values) for k in FEATURES}
  labels = tf.constant(data_set[LABEL].values)
  return feature_cols, labels



# 特征列，可以定义列名，数据尺寸，缺省值，数据类型，正规化器等
feature_cols = [tf.contrib.layers.real_valued_column(k)
                  for k in FEATURES]
print("特征列")
print(feature_cols)

print("输入函数返回")
print(input_fn(test_set))


# 构建两层DNN型神经网络，每层10个节点，指定特征列定义
regressor = tf.contrib.learn.DNNRegressor(feature_columns=feature_cols,
                                            hidden_units=[10, 10],
                                            model_dir="/tmp/boston_model")

# 训练，指明输入函数，迭代次数
regressor.fit(input_fn=lambda: input_fn(training_set), steps=5000)

# 评估模型
ev = regressor.evaluate(input_fn=lambda: input_fn(test_set), steps=1)
loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))

# 预测新的样例
y = regressor.predict(input_fn=lambda: input_fn(prediction_set))
# .predict() 返回一个迭代器；转换为列表并打印预测
predictions = list(itertools.islice(y, 6))
print("Predictions: {}".format(str(predictions)))

tf.logging.set_verbosity(tf.logging.INFO) #开启INFO级别日志

validation_monitor = tf.contrib.learn.monitors.ValidationMonitor(
    test_set.data,
    test_set.target,
    every_n_steps=50)

classifier = tf.contrib.learn.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[10, 20, 10],
    n_classes=3,
    model_dir="/tmp/iris_model",
    config=tf.contrib.learn.RunConfig(save_checkpoints_secs=1))

classifier.fit(x=training_set.data,
               y=training_set.target,
               steps=2000,
               monitors=[validation_monitor])

validation_metrics = {
    "accuracy":
        tf.contrib.learn.MetricSpec(
            metric_fn=tf.contrib.metrics.streaming_accuracy,
            prediction_key=tf.contrib.learn.PredictionKey.CLASSES),
    "precision":
        tf.contrib.learn.MetricSpec(
            metric_fn=tf.contrib.metrics.streaming_precision,
            prediction_key=tf.contrib.learn.PredictionKey.CLASSES),
    "recall":
        tf.contrib.learn.MetricSpec(
            metric_fn=tf.contrib.metrics.streaming_recall,
            prediction_key=tf.contrib.learn.PredictionKey.CLASSES)
}

validation_monitor = tf.contrib.learn.monitors.ValidationMonitor(
    test_set.data,
    test_set.target,
    every_n_steps=50,
    metrics=validation_metrics)

validation_monitor = tf.contrib.learn.monitors.ValidationMonitor(
    test_set.data,
    test_set.target,
    every_n_steps=50,
    metrics=validation_metrics,
    early_stopping_metric="loss",
    early_stopping_metric_minimize=True,
    early_stopping_rounds=200)

tensorboard --logdir=/tmp/iris_model/

# 创建两个变量
weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),
                      name="weights")
biases = tf.Variable(tf.zeros([200]), name="biases")
print(weights, biases)

# 添加一个初始化变量的操作
init_op = tf.global_variables_initializer()

# 然后当运行模型时
with tf.Session() as sess:
    # 运行初始化操作。
    sess.run(init_op)

    # 使用模型
		#...

weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),
                      name="weights") #随机初始化变量
# 创建另一个与“权重”值相同的变量。
w2 = tf.Variable(weights.initialized_value(), name="w2")
# 创建另一个变量，其值为“权重”的两倍
w_twice = tf.Variable(weights.initialized_value() * 2.0, name="w_twice")

tf.variables_initializer()

save_path = saver.save(sess, "/tmp/model.ckpt")

saver.restore(sess, "/tmp/model.ckpt")

def my_image_filter(input_images):
    conv1_weights = tf.Variable(tf.random_normal([5, 5, 32, 32]),
        name="conv1_weights")
    conv1_biases = tf.Variable(tf.zeros([32]), name="conv1_biases")
    conv1 = tf.nn.conv2d(input_images, conv1_weights,
        strides=[1, 1, 1, 1], padding='SAME')
    relu1 = tf.nn.relu(conv1 + conv1_biases)

    conv2_weights = tf.Variable(tf.random_normal([5, 5, 32, 32]),
        name="conv2_weights")
    conv2_biases = tf.Variable(tf.zeros([32]), name="conv2_biases")
    conv2 = tf.nn.conv2d(relu1, conv2_weights,
        strides=[1, 1, 1, 1], padding='SAME')
    return tf.nn.relu(conv2 + conv2_biases)

variables_dict = {
    "conv1_weights": tf.Variable(tf.random_normal([5, 5, 32, 32]),
        name="conv1_weights")
    "conv1_biases": tf.Variable(tf.zeros([32]), name="conv1_biases")
    ... etc. ...
}

def my_image_filter(input_images, variables_dict):
    conv1 = tf.nn.conv2d(input_images, variables_dict["conv1_weights"],
        strides=[1, 1, 1, 1], padding='SAME')
    relu1 = tf.nn.relu(conv1 + variables_dict["conv1_biases"])

    conv2 = tf.nn.conv2d(relu1, variables_dict["conv2_weights"],
        strides=[1, 1, 1, 1], padding='SAME')
    return tf.nn.relu(conv2 + variables_dict["conv2_biases"])

# Both calls to my_image_filter() now use the same variables
result1 = my_image_filter(image1, variables_dict)
result2 = my_image_filter(image2, variables_dict)

def conv_relu(input, kernel_shape, bias_shape):
    # 创建 "weights" 变量.
    weights = tf.get_variable("weights", kernel_shape,
        initializer=tf.random_normal_initializer())
    # 创建 "biases" 变量.
    biases = tf.get_variable("biases", bias_shape,
        initializer=tf.constant_initializer(0.0))
    conv = tf.nn.conv2d(input, weights,
        strides=[1, 1, 1, 1], padding='SAME')
    return tf.nn.relu(conv + biases)

def my_image_filter(input_images):
    with tf.variable_scope("conv1"):
        # 这儿将创建名叫 "conv1/weights", "conv1/biases" 的变量.
        relu1 = conv_relu(input_images, [5, 5, 1, 32], [32])
    with tf.variable_scope("conv2"):
        # 这儿将创建名叫 "conv2/weights", "conv2/biases" 的变量.
        return conv_relu(relu1, [5, 5, 32, 32], [32])

result1 = my_image_filter(image1)
result2 = my_image_filter(image2)
# Raises ValueError(... conv1/weights already exists ...)

with tf.variable_scope("image_filters") as scope:
    result1 = my_image_filter(image1)
    scope.reuse_variables()
    result2 = my_image_filter(image2)

v = tf.get_variable(name, shape, dtype, initializer)

with tf.variable_scope("foo"):
    with tf.variable_scope("bar"):
        v = tf.get_variable("v", [1])
assert v.name == "foo/bar/v:0"

with tf.variable_scope("foo"):
    v = tf.get_variable("v", [1])
    tf.get_variable_scope().reuse_variables()
    v1 = tf.get_variable("v", [1])
assert v1 is v

with tf.variable_scope("root"):
    # At start, the scope is not reusing.
    # 刚开作用域变量不能重用
    assert tf.get_variable_scope().reuse == False
    with tf.variable_scope("foo"):
        # Opened a sub-scope, still not reusing.
        # 打开子作用域变量不能重用
        assert tf.get_variable_scope().reuse == False
    with tf.variable_scope("foo", reuse=True):
        # 显示的打开自作用域重用
        assert tf.get_variable_scope().reuse == True
        with tf.variable_scope("bar"):
            # 自作用于继承了父作用域重用
            assert tf.get_variable_scope().reuse == True
    # 返回父作用域，任然是不可重用
    assert tf.get_variable_scope().reuse == False

with tf.variable_scope("foo") as foo_scope:
    v = tf.get_variable("v", [1])
with tf.variable_scope(foo_scope):
    w = tf.get_variable("w", [1])
with tf.variable_scope(foo_scope, reuse=True):
    v1 = tf.get_variable("v", [1])
    w1 = tf.get_variable("w", [1])
assert v1 is v
assert w1 is w

# 变量作用域变量缺省初始化设定
with tf.Session() as sess:
    with tf.variable_scope("foo4", initializer=tf.constant_initializer(0.4)):
        v = tf.get_variable("v", [1])
        init = tf.global_variables_initializer()
        sess.run(init)
        assert v.eval(sess) == 0.4  # Default initializer as set above.
        w = tf.get_variable("w", [1], initializer=tf.constant_initializer(0.3))
        init = tf.global_variables_initializer()
        sess.run(init)
        assert w.eval() == 0.3  # Specific initializer overrides the default.
        with tf.variable_scope("bar"):
            v = tf.get_variable("v", [1])
            init = tf.global_variables_initializer()
            sess.run(init)
            assert v.eval() == 0.4  # Inherited default initializer.
        with tf.variable_scope("baz", initializer=tf.constant_initializer(0.2)):
            v = tf.get_variable("v", [1])
            init = tf.global_variables_initializer()
            sess.run(init)
            assert v.eval() == 0.2  # Changed default initializer.

with tf.variable_scope("foo"):
    x = 1.0 + tf.get_variable("v", [1])
assert x.op.name == "foo/add"

with tf.variable_scope("foo"):
    with tf.name_scope("bar"):
        v = tf.get_variable("v", [1])
        x = 1.0 + v
assert v.name == "foo/v:0"
assert x.op.name == "foo/bar/add"

import tensorflow as tf

q = tf.FIFOQueue(3,"float") #创建一个队列对象，容量3，数据类型float
init = q.enqueue_many(([0.,0.,0.],)) #向队列中添加元素

x = q.dequeue() #取出元素
y = x + 1 #+1
q_inc = q.enqueue([y]) #再放回

sess = tf.Session()

with sess.as_default():
    init.run() #0 0 0
    q_inc.run() #1 0 0
    q_inc.run() #1 1 0
    q_inc.run() #1 1 1
    q_inc.run() #2 1 1

import threading
num = 0

# 线程主体：循环直到协调器指示请求停止。
# 如果某些条件成立，请协调员停止。
def MyLoop(coord):
  while not coord.should_stop(): #本线程是否停止
    # ...do something...
    global num
    num += 1
    print(num)
    coord.request_stop() #请求本线程停止
    # if ...some condition...
    #  coord.request_stop()

# 主线程：创建一个协调器(coordinator)
coord = tf.train.Coordinator()

# 创建10个线程运行'MyLoop()'
threads = [threading.Thread(target=MyLoop, args=(coord,)) for i in range(10)]

# 启动线程并等待所有的线程停止。
for t in threads:
  t.start()
coord.join(threads)

example = ...ops to create one example...
# 创建一个队列，一个op在队列中一次插入一个示例。
queue = tf.RandomShuffleQueue(...)
enqueue_op = queue.enqueue(example)
# 创建一个训练图，首先出现一批示例。
inputs = queue.dequeue_many(batch_size)
train_op = ...use 'inputs' to build the training part of the graph...

# Create a queue runner that will run 4 threads in parallel to enqueue
# examples.
qr = tf.train.QueueRunner(queue, [enqueue_op] * 4)

# Launch the graph.
sess = tf.Session()
# Create a coordinator, launch the queue runner threads.
coord = tf.train.Coordinator()
enqueue_threads = qr.create_threads(sess, coord=coord, start=True)
# Run the training loop, controlling termination with the coordinator.
for step in xrange(1000000):
    if coord.should_stop():
        break
    sess.run(train_op)
# When done, ask the threads to stop.
coord.request_stop()
# And wait for them to actually do it.
coord.join(enqueue_threads)

try:
    for step in xrange(1000000):
        if coord.should_stop():
            break
        sess.run(train_op)
except Exception, e:
    # Report exceptions to the coordinator.
    coord.request_stop(e)
finally:
    # Terminate as usual. It is safe to call `coord.request_stop()` twice.
    coord.request_stop()
    coord.join(threads)

with tf.Session():
  input = tf.placeholder(tf.float32)
  classifier = ...
  print(classifier.eval(feed_dict={input: my_python_preprocessing_fn()}))

#创建文件名列表
fileNameList = [("file%d"%i) for i in range(5)]
# print(tf.train.match_filenames_once())
print(fileNameList)

#构建文件名队列
fileNamequeue = tf.train.string_input_producer(fileNameList,shuffle=True)
print(fileNamequeue)

# 空列情况下默认值. 同时制定数据类型
record_defaults = [[1.], [1.], [1.], [1.], [1.],[1.], [1.],[1], [1.], [1.]]
col1, col2, col3, col4, col5,col6, col7, col8, col9,col10 = tf.decode_csv(
    value, record_defaults=record_defaults)
features = tf.stack([col1, col2, col3, col4, col5,col6, col7, col9,col10])

with tf.Session() as sess:
  # 开始填充文件名队列
  coord = tf.train.Coordinator()
  threads = tf.train.start_queue_runners(coord=coord)

  for i in range(101):
    # 检索单个实例：
    example, label = sess.run([features, col8])
    print(example,label)

  coord.request_stop()
  coord.join(threads)

# 读取文件并格式化
def read_my_file_format(filename_queue):
  reader = tf.SomeReader()
  key, record_string = reader.read(filename_queue)
  example, label = tf.some_decoder(record_string)
  processed_example = some_processing(example)
  return processed_example, label

# 输入函数
def input_pipeline(filenames, batch_size, num_epochs=None):
  filename_queue = tf.train.string_input_producer(
      filenames, num_epochs=num_epochs, shuffle=True) #创建文件名队列
  example, label = read_my_file_format(filename_queue)
  # min_after_dequeue 定义有多大的随机抽取的缓冲区
  #   设定大意味着，随机化程度高，但是启动更慢，内存使用更多
  # 容量必须大于min_after_dequeue，并且数量较大确定我们将预取的最大值。建议：
  #   min_after_dequeue + (num_threads + a small safety margin) * batch_size
  min_after_dequeue = 10000
  capacity = min_after_dequeue + 3 * batch_size
  example_batch, label_batch = tf.train.shuffle_batch(
      [example, label], batch_size=batch_size, capacity=capacity,
      min_after_dequeue=min_after_dequeue)
  #example_batch, label_batch = tf.train.shuffle_batch_join(
  #    example_list, batch_size=batch_size, capacity=capacity,
  #    min_after_dequeue=min_after_dequeue) #多文件混淆
  return example_batch, label_batch

init_op = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init_op)

# 开启输入线程队列
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)

try:
    while not coord.should_stop():
        # 运行训练步骤或者其他什么
        sess.run(train_op)
except tf.errors.OutOfRangeError: #异常
    print('Done training -- epoch limit reached')
finally:
    # 关闭线程
    coord.request_stop()

# 等待线程结束
coord.join(threads)
sess.close()

training_data = ...
training_labels = ...
with tf.Session():
  input_data = tf.constant(training_data)
  input_labels = tf.constant(training_labels)
  ...

training_data = ...
training_labels = ...
with tf.Session() as sess:
  data_initializer = tf.placeholder(dtype=training_data.dtype,
                                    shape=training_data.shape)
  label_initializer = tf.placeholder(dtype=training_labels.dtype,
                                     shape=training_labels.shape)
  input_data = tf.Variable(data_initializer, trainable=False, collections=[])
  input_labels = tf.Variable(label_initializer, trainable=False, collections=[])
  ...
  sess.run(input_data.initializer,
           feed_dict={data_initializer: training_data})
  sess.run(input_labels.initializer,
           feed_dict={label_initializer: training_labels})