model_name = "my_model"

# 学習したCNNフィルタ(4次元のW_Conv)の書き出し 軸を転置させる必要があることに注意

weight_transposed = tf.transpose(W_conv, [3, 0, 1, 2])
tf.summary.image("W0/" + model_name, weight_transposed, max_outputs=20)

# ロスなどスカラ値の書き出し

tf.summary.scalar("test_loss/" + model_name, loss)

#ウェイトやバイアスの平均値や最大値、分散やヒストグラムの時間変化

with tf.name_scope("my_variable"):
  tf.summary.scalar("mean/" + model_name, tf.reduce_mean(var))
  tf.summary.scalar("stddev/" + model_name, tf.sqrt(tf.reduce_mean(tf.square(var - tf.reduce_mean(var)))))
  tf.summary.scalar("max/" + model_name, tf.reduce_max(var))
  tf.summary.scalar("min/" + model_name, tf.reduce_min(var))
  tf.summary.histogram(model_name, var)


# 各種 tf.summary.***() を呼んでグラフを作った後、各サマリーグラフを統合取得する

summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter("tf_log", graph=sess.graph)

saver = tf.train.Saver()

summary_str = sess.run([summary_op], feed_dict={self.x:images, self.y:test_images})

summary_writer.add_summary(summary_str, step)
summary_writer.flush()

# グラフ内のlossをeval()を使わずにコンソールに表示

loss = tf.Print(loss, [loss], message="Loss:")

# グラフ内の1次元テンソーオブジェクト tensor の内容を表示

print("Tensor[%s] shape=%s" % (tensor.name, str(tensor.get_shape())))
tensor_values = tensor.eval()
line = ""

for i in range(tensor_values.shape[0]):
  line += "%2.3f " % tensor_values[i]
print(line)

# トレーニング可能な変数とその次元を列挙、合計する

total_parameters = 0
parameters_string = ""

for variable in tf.trainable_variables():

  shape = variable.get_shape()
  variable_parameters = 1
  for dim in shape:
    variable_parameters *= dim.value
  total_parameters += variable_parameters
  if len(shape) == 1:
    parameters_string += ("%s %d, " % (variable.name, variable_parameters))
  else:
    parameters_string += ("%s %s=%d, " % (variable.name, str(shape), variable_parameters))

print(parameters_string)
print("Total %d variables, %s params" % (len(tf.trainable_variables()), "{:,}".format(total_parameters)))

import matplotlib.pyplot as plt

csv_epochs = []
csv_loss = []
csv_training_loss = []

# 各epochで下記のようにその時のepochとlossなどを追加していく
csv_epochs.append(epochs)
csv_loss.append(loss)
csv_training_loss.append(training_loss)

# 計算中あるいは計算終了時にpngグラフを作成
plt.plot(csv_epochs, csv_training_loss, "b", label="Training Loss")
plt.plot(csv_epochs, csv_loss, "r", label="Test Loss")
plt.vlines(csv_epochs[-1], 0, csv_loss[-1], color='0.75')
plt.hlines(csv_loss[-1], 0, csv_epochs[-1], color='0.75')
plt.savefig("graphs/model_name.png")

import numpy as np

# 上の通りにcsv_epochs などを作成したとして

loss_graph = np.column_stack((csv_epochs, csv_loss, csv_training_loss))
np.savetxt("graphs/model_name.csv", loss_graph, delimiter=",")

psnr_value = 20 * math.log(max_value / math.sqrt(mse), 10)
step = 10
summary = tf.Summary(value=[tf.Summary.Value(tag="test_PSNR", simple_value=psnr_value)])
writer = tf.summary.FileWriter("tf_log_dir/test", graph=sess.graph)
writer.add_summary(summary, step)
writer.flush()

# convテンソーの出力にLeaky ReLUをかける

h = tf.maximum(conv, 0.1 * conv)

# 入力x に対して ウェイトw のCNNフィルタを作成し、各出力に対してのα変数を作成。Parametric ReLUを作成する

conv = tf.nn.conv2d(x, w, strides=[stride, stride, 1, 1], padding="SAME")

alphas = tf.Variable(tf.constant(0.1, shape=[w.get_shape()[3]]))
h = tf.nn.relu(conv) + tf.multiply(alphas, (conv - tf.abs(conv))) * 0.5

# Dilated CNNのサンプル. rateで指定した分だけ飛んでCNNを適用する

conv = tf.nn.atrous_conv2d(x, w, rate, padding="SAME")

# Transposed CNNのサンプル. stridesで指定した分だけ値をゼロで補完してCNNを適用する

h = tf.nn.conv2d_transpose(x, w, output_shape=output_shape, strides=strides, padding='SAME')

# shape = 初期化するウェイトの次元として、4次元のCNNの場合は下記

fan_in = shape[0] * shape[1] * shape[2]
fan_out = shape[0] * shape[1] * shape[3]
n = fan_in + fan_out

# さらに一様の分布にする場合は下記

init_range = math.sqrt(6.0 / n)
initial = tf.random_uniform(shape, minval=-init_range, maxval=init_range)
weight = tf.Variable(initial, name=name)

# さらに正規分布にする場合は下記

stddev = math.sqrt(3.0 / n)
initial = tf.truncated_normal(shape=shape, stddev=stddev)
weight = tf.Variable(initial, name=name)

# shape = 初期化するウェイトの次元として、4次元のCNNの場合は下記

n = shape[0] * shape[1] * shape[2]
stddev = math.sqrt(2.0 / n)
initial = tf.truncated_normal(shape=shape, stddev=stddev)
weight = tf.Variable(initial, name=name)

# L1正則化項をlossに加える

l1_loss = 0.001 * tf.reduce_sum( tf.abs( W_conv0 ) + tf.abs( W_conv1 ) + ... )
train_step = tf.train.GradientDescentOptimizer(0.05).minimize(loss+l1_loss)

# ウェイト配列のL2正則化項をlossに加える

l2_decay = 0.0001
weights = 5 * [None]
weights[0] = tf.truncated_normal(shape=shape, stddev=stddev)
...

l2_losses = [tf.nn.l2_loss(w) for w in weights]
l2_loss = l2_decay * tf.add_n(l2_losses)

# 各層の出力hに対して、下記の値を全て足し合わせてlossに加える

sparse_regularization_values += tf.reduce_mean(tf.log(1 + h * h))
sparse_regularization_values *= 0.0001
loss += sparse_regularization_values

# trainingフェーズであるかどうかの入力ポイントを作成
phase = tf.placeholder(tf.bool, name="phase")

# グラフ作成時にBN層を追加
conv = tf.contrib.layers.batch_norm(x, center=True, scale=True, is_training=phase, scope='bn')

# セッションの実行時に、トレーニング中は1、推論時は0を指定する
feed_dict = {..., phase: 1}

optimizer = tf.train.AdamOptimizer(lr_input, beta1=self.beta1, beta2=self.beta2)

#通常はoptimzerを定義したらそのまま下記のようにロスを入れるが、
#training_optimizer = optimizer.minimize(loss)

#GCではまずトレーニングできる変数を列挙し、それらの勾配を計算する。
trainables = tf.trainable_variables()
grads = tf.gradients(loss, trainables)

#その後、clipping_normに指定した値を上限としてクリッピングし、オプティマイズする
grads, _ = tf.clip_by_global_norm(grads,　clip_norm=clipping_norm)
grad_var_pairs = zip(grads, trainables)
gc_optimizer = optimizer.apply_gradients(grad_var_pairs)

# トレーニング時はdropoutを設定し、テスト時はdropoutを行わないために入力用のplaceholderを作成する

dropout_input = tf.placeholder(tf.float32, shape=[], name="dropout_keep_rate")

# 出力hにdropoutを適用する
h = tf.nn.dropout(h, dropout_input)

# トレーニング時／テスト時などに合わせてdropout rateを指定する
sess.run(optimizer, feed_dict={self.x: input, self.y: true, dropout_input: 0.8})

# 注意事項として、Saver作成時にmax_to_keep=Noneを指定しておくこと。
# こうしないとある規定数以上のファイルを保存した時に自動的に古いものから削除されてしまう
saver = tf.train.Saver(max_to_keep=None)

# テストセットで最高の性能が出た場合にモデルを保存する
saver.save(sess, filename)

# テストセットでの性能が落ち始めたら保存していたモデルをリストアする
# あるいはモデル初期化時に sess.run(tf.global_variables_initializer()) の代わりに呼び出す
saver.restore(sess, filename)

# CNN 5層分のウェイトを作成し、名前の先頭に "C_"をつける
W_conv = 5 * [None]
for i in range(5):
  initial = tf.truncated_normal(shape=[3, 3, 64, 64], stddev=0.01, name=("C_W%d_conv" % i.level))
  W_conv[i] = tf.Variable(initial)

# 名前の先頭に"C_"がついた変数だけを取得し、それら用のsaverを作成し利用
saver_c = tf.train.Saver([v for v in tf.all_variables() if v.name.startswith("C_")])

saver_c.restore(sess, filename)

# 上記と同様にファィンチューンしたい最終弾のウェイトのみに "F_"で始まる名前をつけます。

Fc1 = tf.Variable(tf.truncated_normal(shape=[1024, 64], stddev=0.01, name=("F_Fc1")))
Fc2 = tf.Variable(tf.truncated_normal(shape=[64, 10], stddev=0.01, name=("F_Fc2")))

# トレーニング可能な変数のうち"F_"で始まるもののみを集め、その勾配を計算し最適化するオプティマイザを作成します
tuning_grads = optimizer.compute_gradients(
  loss,
  [v for v in tf.trainable_variables() if (v.name.startswith("F_"))]
)
tuning_optimizer = optimizer.apply_gradients(tuning_grads)

# ファインチューニングを行う場合、行わない場合とでそれぞれ別のオプティマイザを利用する
if tuning:
  optimizer = tuning_optimizer
else:
  optimizer = training_optimizer
_, loss_eval = sess.run([optimizer, loss], feed_dict={self.x: batch_input, self.y: batch_true})