tf.flags與tf.app.flags

在看了衆多關于flags與app.flags的文獻後，了解程度還是有點迷茫。

1.Â import tensorflow as tf

2.Â FLAGS=tf.app.flags.FLAGS

3.Â tf.app.flags.DEFINE_float(

4.Â 'flag_float', 0.01, 'input a float')

5.Â tf.app.flags.DEFINE_integer(

6.Â 'flag_int', 400, 'input a int')

7.Â tf.app.flags.DEFINE_boolean(

8.Â 'flag_bool', True, 'input a bool')

9.Â tf.app.flags.DEFINE_string(

10.Â 'flag_string', 'yes', 'input a string')

11.Â

12.Â print(FLAGS.flag_float)

13.Â print(FLAGS.flag_int)

14.Â print(FLAGS.flag_bool)

15.Â print(FLAGS.flag_string)

1.在指令行中檢視幫助資訊，在指令行輸入 python test.py -h

注意紅色框中的資訊，這個就是我們用DEFINE_XXX添加指令行參數時的第三個參數

2.直接運作test.py

因為沒有給對應的指令行參數指派，是以輸出的是指令行參數的預設值。

3.帶指令行參數的運作test.py檔案

這裡輸出了我們賦給指令行參數的值

tf.app.flags.DEFINE_xxx()就是添加指令行的optional argument（可選參數），

而tf.app.flags.FLAGS可以從對應的指令行參數取出參數。

DEFINE_string()限定了可選參數輸入必須是string，這也就是為什麼這個函數定義為DEFINE_string()，同理，DEFINE_int()限定可選參數必須是int，DEFINE_float()限定可選參數必須是float，DEFINE_boolean()限定可選參數必須是bool。

最關鍵的一步，這裡定義了_FlagValues這個類的一個執行個體,這樣的這樣當要通路指令行輸入的指令時，就能使用像tf.app.flag.Flags這樣的操作。

從：使用CNN做英文文本任務執行個體來看flags用法

import tensorflow as tfimport numpy as npimport osimport timeimport datetimeimport data_helpersfrom text_cnn import TextCNNfrom tensorflow.contrib import learn

# Parameters# ==================================================

# Data loading params# 語料檔案路徑定義

tf.flags.DEFINE_float("dev_sample_percentage", .1, "Percentage of the training data to use for validation")

tf.flags.DEFINE_string("positive_data_file", "./data/rt-polaritydata/rt-polarity.pos", "Data source for the positive data.")

tf.flags.DEFINE_string("negative_data_file", "./data/rt-polaritydata/rt-polarity.neg", "Data source for the negative data.")

# Model Hyperparameters# 定義網絡超參數

tf.flags.DEFINE_integer("embedding_dim", 128, "Dimensionality of character embedding (default: 128)")

tf.flags.DEFINE_string("filter_sizes", "3,4,5", "Comma-separated filter sizes (default: '3,4,5')")

tf.flags.DEFINE_integer("num_filters", 128, "Number of filters per filter size (default: 128)")

tf.flags.DEFINE_float("dropout_keep_prob", 0.5, "Dropout keep probability (default: 0.5)")

tf.flags.DEFINE_float("l2_reg_lambda", 0.0, "L2 regularization lambda (default: 0.0)")

# Training parameters# 訓練參數

tf.flags.DEFINE_integer("batch_size", 32, "Batch Size (default: 32)")

tf.flags.DEFINE_integer("num_epochs", 200, "Number of training epochs (default: 200)") # 總訓練次數

tf.flags.DEFINE_integer("evaluate_every", 100, "Evaluate model on dev set after this many steps (default: 100)") # 每訓練100次測試一下

tf.flags.DEFINE_integer("checkpoint_every", 100, "Save model after this many steps (default: 100)") # 儲存一次模型

tf.flags.DEFINE_integer("num_checkpoints", 5, "Number of checkpoints to store (default: 5)")# Misc Parameters

tf.flags.DEFINE_boolean("allow_soft_placement", True, "Allow device soft device placement") # 加上一個布爾類型的參數，要不要自動配置設定

tf.flags.DEFINE_boolean("log_device_placement", False, "Log placement of ops on devices") # 加上一個布爾類型的參數，要不要列印日志

# 列印一下相關初始參數

FLAGS = tf.flags.FLAGS

FLAGS._parse_flags()

print("\nParameters:")for attr, value in sorted(FLAGS.__flags.items()):

print("{}={}".format(attr.upper(), value))

print("")

# Data Preparation# ==================================================

# Load data

print("Loading data...")

x_text, y = data_helpers.load_data_and_labels(FLAGS.positive_data_file, FLAGS.negative_data_file)

# Build vocabulary

max_document_length = max([len(x.split(" ")) for x in x_text]) # 計算最長郵件

vocab_processor = learn.preprocessing.VocabularyProcessor(max_document_length) # tensorflow提供的工具，将資料填充為最大長度，預設0填充

x = np.array(list(vocab_processor.fit_transform(x_text)))

# Randomly shuffle data# 資料洗牌

np.random.seed(10)# np.arange生成随機序列

shuffle_indices = np.random.permutation(np.arange(len(y)))

x_shuffled = x[shuffle_indices]

y_shuffled = y[shuffle_indices]

# 将資料按訓練train和測試dev分塊# Split train/test set# TODO: This is very crude, should use cross-validation

dev_sample_index = -1 * int(FLAGS.dev_sample_percentage * float(len(y)))

x_train, x_dev = x_shuffled[:dev_sample_index], x_shuffled[dev_sample_index:]

y_train, y_dev = y_shuffled[:dev_sample_index], y_shuffled[dev_sample_index:]

print("Vocabulary Size: {:d}".format(len(vocab_processor.vocabulary_)))

print("Train/Dev split: {:d}/{:d}".format(len(y_train), len(y_dev))) # 列印切分的比例

# Training# ==================================================

with tf.Graph().as_default():

session_conf = tf.ConfigProto(

allow_soft_placement=FLAGS.allow_soft_placement,

log_device_placement=FLAGS.log_device_placement)

sess = tf.Session(config=session_conf)

with sess.as_default():

# 卷積池化網絡導入

cnn = TextCNN(

sequence_length=x_train.shape[1],

num_classes=y_train.shape[1], # 分幾類

vocab_size=len(vocab_processor.vocabulary_),

embedding_size=FLAGS.embedding_dim,

filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))), # 上面定義的filter_sizes拿過來，"3,4,5"按","分割

num_filters=FLAGS.num_filters, # 一共有幾個filter

l2_reg_lambda=FLAGS.l2_reg_lambda) # l2正則化項

# Define Training procedure

global_step = tf.Variable(0, name="global_step", trainable=False)

optimizer = tf.train.AdamOptimizer(1e-3) # 定義優化器

grads_and_vars = optimizer.compute_gradients(cnn.loss)

train_op = optimizer.apply_gradients(grads_and_vars, global_step=global_step)

# Keep track of gradient values and sparsity (optional)

grad_summaries = []

for g, v in grads_and_vars:

if g is not None:

grad_hist_summary = tf.summary.histogram("{}/grad/hist".format(v.name), g)

sparsity_summary = tf.summary.scalar("{}/grad/sparsity".format(v.name), tf.nn.zero_fraction(g))

grad_summaries.append(grad_hist_summary)

grad_summaries.append(sparsity_summary)

grad_summaries_merged = tf.summary.merge(grad_summaries)

# Output directory for models and summaries

timestamp = str(int(time.time()))

out_dir = os.path.abspath(os.path.join(os.path.curdir, "runs", timestamp))

print("Writing to {}\n".format(out_dir))

# Summaries for loss and accuracy

# 損失函數和準确率的參數儲存

loss_summary = tf.summary.scalar("loss", cnn.loss)

acc_summary = tf.summary.scalar("accuracy", cnn.accuracy)

# Train Summaries

# 訓練資料儲存

train_summary_op = tf.summary.merge([loss_summary, acc_summary, grad_summaries_merged])

train_summary_dir = os.path.join(out_dir, "summaries", "train")

train_summary_writer = tf.summary.FileWriter(train_summary_dir, sess.graph)

# Dev summaries

# 測試資料儲存

dev_summary_op = tf.summary.merge([loss_summary, acc_summary])

dev_summary_dir = os.path.join(out_dir, "summaries", "dev")

dev_summary_writer = tf.summary.FileWriter(dev_summary_dir, sess.graph)

# Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it

checkpoint_dir = os.path.abspath(os.path.join(out_dir, "checkpoints"))

checkpoint_prefix = os.path.join(checkpoint_dir, "model")

if not os.path.exists(checkpoint_dir):

os.makedirs(checkpoint_dir)

saver = tf.train.Saver(tf.global_variables(), max_to_keep=FLAGS.num_checkpoints) # 前面定義好參數num_checkpoints

# Write vocabulary

vocab_processor.save(os.path.join(out_dir, "vocab"))

# Initialize all variables

sess.run(tf.global_variables_initializer()) # 初始化所有變量

# 定義訓練函數

def train_step(x_batch, y_batch):

"""

A single training step

feed_dict = {

cnn.input_x: x_batch,

cnn.input_y: y_batch,

cnn.dropout_keep_prob: FLAGS.dropout_keep_prob # 參數在前面有定義

}

_, step, summaries, loss, accuracy = sess.run(

[train_op, global_step, train_summary_op, cnn.loss, cnn.accuracy], feed_dict)

time_str = datetime.datetime.now().isoformat() # 取目前時間，python的函數

print("{}: step {}, loss {:g}, acc {:g}".format(time_str, step, loss, accuracy))

train_summary_writer.add_summary(summaries, step)

# 定義測試函數

def dev_step(x_batch, y_batch, writer=None):

Evaluates model on a dev set

cnn.dropout_keep_prob: 1.0 # 神經元全部保留

step, summaries, loss, accuracy = sess.run(

[global_step, dev_summary_op, cnn.loss, cnn.accuracy], feed_dict)

time_str = datetime.datetime.now().isoformat()

if writer:

writer.add_summary(summaries, step)

# Generate batches

batches = data_helpers.batch_iter(list(zip(x_train, y_train)), FLAGS.batch_size, FLAGS.num_epochs)

# Training loop. For each batch...

# 訓練部分

for batch in batches:

x_batch, y_batch = zip(*batch) # 按batch把資料拿進來

train_step(x_batch, y_batch)

current_step = tf.train.global_step(sess, global_step) # 将Session和global_step值傳進來

if current_step % FLAGS.evaluate_every == 0: # 每FLAGS.evaluate_every次每100執行一次測試

print("\nEvaluation:")

dev_step(x_dev, y_dev, writer=dev_summary_writer)

print("")

if current_step % FLAGS.checkpoint_every == 0: # 每checkpoint_every次執行一次儲存模型

path = saver.save(sess, './', global_step=current_step) # 定義模型儲存路徑

print("Saved model checkpoint to {}\n".format(path))

tf定義了tf.app.flags，用于支援接受指令行傳遞參數，相當于接受argv。

import tensorflow as tf

#第一個是參數名稱，第二個參數是預設值，第三個是參數描述

tf.app.flags.DEFINE_string('str_name', 'def_v_1',"descrip1")

tf.app.flags.DEFINE_integer('int_name', 10,"descript2")

tf.app.flags.DEFINE_boolean('bool_name', False, "descript3")

FLAGS = tf.app.flags.FLAGS

#必須帶參數，否則：'TypeError: main() takes no arguments (1 given)'; main的參數名随意定義，無要求def main(_):

print(FLAGS.str_name)

print(FLAGS.int_name)

print(FLAGS.bool_name)

if __name__ == '__main__':

tf.app.run() #執行main函數

執行：

def_v_1

False

# python tt.py --str_name test_str --int_name 99 --bool_name True

test_str

True

tf.flags與tf.app.flags

繼續閱讀

無法解析的外部符号 wmain，該符号在函數 "void cdecl mainCRTStartupHelper(struct HINSTANCE *,unsigned short con......

TestLink導出用例轉換工具(XML2Excel)

解碼器用于語義分割：資料依賴的解碼可以實作靈活的特征聚合

YAML簡介和PyYAML安全操作YAML支援的類型YAML的優點：yaml的基本文法python操作

Small tricks

libsvm for python 安裝

學習軟體測試基礎測試第七天

Zeppelin 配置通路 REST APIApache Zeppelin Configuration REST API

【Torch】最簡潔logging使用指南

27. Remove Element(清單)題目代碼

Cloud Studio初體驗

使用 ctypes 進行 Python 和 C 的混合程式設計

【python】【資料處理】畫多元資料分布圖

【python】netconf協定對接管理裝置

「Python 網絡自動化」NETCONF —— Python 使用 NETCONF 管理配置 H3C 網絡裝置

在python中建立excel并寫入