zakio49 score 29
2017/07/01 18:14 投稿
| Tensorflow：一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。 |
| 前提・実現したいこと |
| こちらの記事のソースコードを参考にNNを組んで見ました。 |
| 一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。お知恵を拝借したいです。よろしくお願い致します。 |
| ニューラルネットワークでプロ野球選手の給与を査定してみる |
| [http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07](http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07) |
| TensorFlowでmodelを保存して復元する |
| [http://testpy.hatenablog.com/entry/2017/02/02/000000](http://testpy.hatenablog.com/entry/2017/02/02/000000) |
| TensorFlowのPythonコードの初歩を噛み砕いてみる |
| [http://qiita.com/To_Murakami/items/5984a4891597b17fc40e](http://qiita.com/To_Murakami/items/5984a4891597b17fc40e) |
| 実行環境はwindows10+Anaconda+python3.5+tensorflow1.0~になります |
| 現状の理解・躓いていると思っている箇所 |
| *修正7/1 17:02 |
| 色々な点を修正させていただき新たな疑問として |
| 復元したモデルを再利用する流れについては |
| 1.変数の読み込み(csvファイル) |
| 2.使えるデータ形式に変化（） |
| 3.学習したときに使ったinterface(score_placeholder)で使える形にモデルを作る |
| 4.meta.ckptを復元して、重みをもとに予想を行う関数(interface)にいれる |
| 5,sess.runを行い予想値をプリントする。 |
| **ただ、実践データは学習データと異なり正解のデータがないのでcsvファイルの列も一つ少ないので、モデルの組み方が異なると、interface関数を変更する必要がでて、model.ckptの値が反映できないのではないかと、その互換性で躓いています。 |
| **ただ、実践データは学習データと異なり正解のデータがないのでcsvファイルの列も一つ少ないので、モデルの組み方が異なると、最初に学習の時に使ったinterface（）関数をそのまま使えないのでwith tf.Session() as sess2:ないで新たに関数を定義したらmodel.ckptの値が反映できないのではないかとそのあたりで躓いています。 |
| 現状の実践データ正解データも込みで行っていますがエラーが発生しておりなかなかうまくいきません。よろしくお願いいたします |
| ** |
| ```` |
| with tf.Session() as sess2: |
| # 変数の読み込み |
| #新しいデータ |
| raw_input2 = numpy.loadtxt(open("one_record.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input2, [1]) |
| #モデルつくり |
| feed_dict_test2 ={ |
| tensor_placeholder: tensor, |
| score_placeholder: score, |
| loss_label_placeholder: "loss_test" |
| } |
| #復元して、損失関数で定まった、重みをもとに予想を行う関数にいれる |
| saver = tf.train.Saver() |
| cwd = os.getcwd() |
| saver.restore(sess2,cwd + "/model.ckpt") |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| print(best_match2) |
| print("fin") |
| sess2.close() |
| ```` |
| エラーコード |
| ```` |
| Traceback (most recent call last): |
| File "tensor_session.py", line 103, in <module> |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 767, in run |
| run_metadata_ptr) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 944, in _run |
| % (np_val.shape, subfeed_t.name, str(subfeed_t.get_shape()))) |
| ValueError: Cannot feed value of shape (1,) for Tensor 'tensor_placeholder:0', which has shape '(?, 1)' |
| ```` |
| > 二重誤差の最小値が重要ではなくて、重みとバイアスが重要であることがよくわかりました。model.ckpt.metaファイルにそれぞれのリンクの重みの値が書かれていなかったので、二重誤差の値から復元できると勘違いしていました。 |
| ↓結局、model.ckpt.metaはブラックボックスのままなのですが（制御コードとか埋め込まれており）リンクによると MetaGraphDef protocol buffer.がmodel.ckpt.metaファイルをもとにプロセスを復元するから、重みの値はその中で復元されるから、直接は書いてないよという理解をしました。 |
| What is the TensorFlow checkpoint meta file? |
| [https://stackoverflow.com/questions/36195454/what-is-the-tensorflow-checkpoint-meta-file/36203288#36203288](https://stackoverflow.com/questions/36195454/what-is-the-tensorflow-checkpoint-meta-file/36203288#36203288) |
| ニューラルネットワークの流れというか保持・復元のしていること（修正） |
| 1,出力層の出力値が教師データに近づいてるのかを表す尺度として損失関数を重みやバイアスで指定した回数（10000回）偏微分を行い。2乗誤差 Eをを小さくしようとする。 |
| 2,その時の重み、ベクトル量を保持する。 |
| 3,新たな入力（実践データ）に対して、保持された重みとバイアス用いて実践データを**inference(score_placeholder)**に入れることで適当な値が予想できると思っています。 |
| *誤差逆伝播法の理解に誤りがありました、入力ノードから次の層へのリンク一つ一つにランダムで割り当てられた重みがつき、それらの和がシグモイド関数orReLU関数に入力されて次の層のノードに入力され、行きついた値と教師データの値との間の誤差をみて、重みを変化させるフィードバックを与えるという理解をしています。 |
| このままだとプログラムの誤差が最小の値を保持していても、復元した際のノード毎に与える重みはどこに保存されているかがわからず困っています。 |
| →直接の値はかかれていないMetaGraphDef protocol bufferの中で復元される認識です（お手上げです） |
| pythonに不慣れなところもあるのですが、困っているのでぜひ答えていただけたら幸いです。 |
| ```` |
| import tensorflow as tf |
| import numpy |
| import os |
| cwd = os.getcwd() |
| SCORE_SIZE = 12 |
| HIDDEN_UNIT_SIZE = 70 |
| TRAIN_DATA_SIZE = 45 |
| raw_input = numpy.loadtxt(open("test.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input, [1]) |
| [tensor_train, tensor_test] = numpy.vsplit(tensor, [TRAIN_DATA_SIZE]) |
| [score_train, score_test] = numpy.vsplit(score, [TRAIN_DATA_SIZE]) |
| def inference(score_placeholder): |
| with tf.name_scope('hidden1') as scope: |
| hidden1_weight = tf.Variable(tf.truncated_normal([SCORE_SIZE, HIDDEN_UNIT_SIZE], stddev=0.1), name="hidden1_weight") |
| hidden1_bias = tf.Variable(tf.constant(0.1, shape=[HIDDEN_UNIT_SIZE]), name="hidden1_bias") |
| hidden1_output = tf.nn.relu(tf.matmul(score_placeholder, hidden1_weight) + hidden1_bias) |
| with tf.name_scope('output') as scope: |
| output_weight = tf.Variable(tf.truncated_normal([HIDDEN_UNIT_SIZE, 1], stddev=0.1), name="output_weight") |
| output_bias = tf.Variable(tf.constant(0.1, shape=[1]), name="output_bias") |
| output = tf.matmul(hidden1_output, output_weight) + output_bias |
| return tf.nn.l2_normalize(output, 0) |
| def loss(output, tensor_placeholder, loss_label_placeholder): |
| with tf.name_scope('loss') as scope: |
| loss = tf.nn.l2_loss(output - tf.nn.l2_normalize(tensor_placeholder, 0)) |
| tf.summary.scalar('loss_label_placeholder', loss) |
| return loss |
| def training(loss): |
| with tf.name_scope('training') as scope: |
| train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss) |
| return train_step |
| with tf.Graph().as_default(): |
| tensor_placeholder = tf.placeholder("float", [None, 1], name="tensor_placeholder") |
| score_placeholder = tf.placeholder("float", [None, SCORE_SIZE], name="score_placeholder") |
| loss_label_placeholder = tf.placeholder("string", name="loss_label_placeholder") |
| feed_dict_train={ |
| tensor_placeholder: tensor_train, |
| score_placeholder: score_train, |
| loss_label_placeholder: "loss_train" |
| } |
| feed_dict_test={ |
| tensor_placeholder: tensor_test, |
| score_placeholder: score_test, |
| loss_label_placeholder: "loss_test" |
| } |
| output = inference(score_placeholder) |
| loss = loss(output, tensor_placeholder, loss_label_placeholder) |
| training_op = training(loss) |
| summary_op = tf.summary.merge_all() |
| init = tf.global_variables_initializer() |
| best_loss = float("inf") |
| with tf.Session() as sess: |
| summary_writer = tf.summary.FileWriter('data', graph_def=sess.graph_def) |
| sess.run(init) |
| for step in range(10000): |
| sess.run(training_op, feed_dict=feed_dict_train) |
| loss_test = sess.run(loss, feed_dict=feed_dict_test) |
| if loss_test < best_loss: |
| best_loss = loss_test |
| best_match = sess.run(output, feed_dict=feed_dict_test) |
| if step % 100 == 0: |
| summary_str = sess.run(summary_op, feed_dict=feed_dict_test) |
| summary_str += sess.run(summary_op, feed_dict=feed_dict_train) |
| summary_writer.add_summary(summary_str, step) |
| saver=tf.train.Saver() |
| saver.save(sess,cwd+'/model.ckpt') |
| print(cwd) |
| print('Saved a model.') |
| sess.close() |
| with tf.Session() as sess2: |
| # 変数の読み込み |
| #新しいデータ |
| raw_input2 = numpy.loadtxt(open("one_record.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input2, [1]) |
| #モデルつくり |
| feed_dict_test2 ={ |
| tensor_placeholder: tensor, |
| score_placeholder: score, |
| loss_label_placeholder: "loss_test" |
| } |
| #復元して、損失関数で定まった、重みをもとに予想を行う関数にいれる |
| saver = tf.train.Saver() |
| cwd = os.getcwd() |
| saver.restore(sess2,cwd + "/model.ckpt") |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| print(best_match2) |
| print("fin") |
| sess2.close() |
| ```` |
zakio49 score 29
2017/07/01 18:10 投稿
| Tensorflow：一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。 |
| 前提・実現したいこと |
| こちらの記事のソースコードを参考にNNを組んで見ました。 |
| 一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。お知恵を拝借したいです。よろしくお願い致します。 |
| ニューラルネットワークでプロ野球選手の給与を査定してみる |
| [http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07](http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07) |
| TensorFlowでmodelを保存して復元する |
| [http://testpy.hatenablog.com/entry/2017/02/02/000000](http://testpy.hatenablog.com/entry/2017/02/02/000000) |
| 実行環境はwindows10+Anaconda+python3.5+tensorflow1.0~になります |
| 現状の理解・躓いていると思っている箇所 |
| *修正7/1 17:02 |
| 色々な点を修正させていただき新たな疑問として |
| 復元したモデルを再利用する流れについては |
| 1.変数の読み込み(csvファイル) |
| 2.使えるデータ形式に変化（） |
| 3.学習したときに使ったinterface(score_placeholder)で使える形にモデルを作る |
| 4.meta.ckptを復元して、重みをもとに予想を行う関数(interface)にいれる |
| 5,sess.runを行い予想値をプリントする。 |
| **ただ、実践データは学習データと異なり正解のデータがないのでcsvファイルの列も一つ少ないので、モデルの組み方が異なると、interface関数を変更する必要がでて、model.ckptの値が反映できないのではないかと、その互換性で躓いています。 |
| ** |
| ```` |
| with tf.Session() as sess2: |
| # 変数の読み込み |
| #新しいデータ |
| raw_input2 = numpy.loadtxt(open("one_record.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input2, [1]) |
| #モデルつくり |
| feed_dict_test2 ={ |
| tensor_placeholder: tensor, |
| score_placeholder: score, |
| loss_label_placeholder: "loss_test" |
| } |
| #復元して、損失関数で定まった、重みをもとに予想を行う関数にいれる |
| saver = tf.train.Saver() |
| cwd = os.getcwd() |
| saver.restore(sess2,cwd + "/model.ckpt") |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| print(best_match2) |
| print("fin") |
| sess2.close() |
| ```` |
| エラーコード |
| ```` |
| Traceback (most recent call last): |
| File "tensor_session.py", line 103, in <module> |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 767, in run |
| run_metadata_ptr) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 944, in _run |
| % (np_val.shape, subfeed_t.name, str(subfeed_t.get_shape()))) |
| ValueError: Cannot feed value of shape (1,) for Tensor 'tensor_placeholder:0', which has shape '(?, 1)' |
| ```` |
| > 二重誤差の最小値が重要ではなくて、重みとバイアスが重要であることがよくわかりました。model.ckpt.metaファイルにそれぞれのリンクの重みの値が書かれていなかったので、二重誤差の値から復元できると勘違いしていました。 |
| ↓結局、model.ckpt.metaはブラックボックスのままなのですが（制御コードとか埋め込まれており）リンクによると MetaGraphDef protocol buffer.がmodel.ckpt.metaファイルをもとにプロセスを復元するから、重みの値はその中で復元されるから、直接は書いてないよという理解をしました。 |
| What is the TensorFlow checkpoint meta file? |
| [https://stackoverflow.com/questions/36195454/what-is-the-tensorflow-checkpoint-meta-file/36203288#36203288](https://stackoverflow.com/questions/36195454/what-is-the-tensorflow-checkpoint-meta-file/36203288#36203288) |
| ニューラルネットワークの流れというか保持・復元のしていること（修正） |
| 1,出力層の出力値が教師データに近づいてるのかを表す尺度として損失関数を重みやバイアスで指定した回数（10000回）偏微分を行い。2乗誤差 Eをを小さくしようとする。 |
| 2,その時の重み、ベクトル量を保持する。 |
| 3,新たな入力（実践データ）に対して、保持された重みとバイアス用いて実践データを**inference(score_placeholder)**に入れることで適当な値が予想できると思っています。 |
| *誤差逆伝播法の理解に誤りがありました、入力ノードから次の層へのリンク一つ一つにランダムで割り当てられた重みがつき、それらの和がシグモイド関数orReLU関数に入力されて次の層のノードに入力され、行きついた値と教師データの値との間の誤差をみて、重みを変化させるフィードバックを与えるという理解をしています。 |
| このままだとプログラムの誤差が最小の値を保持していても、復元した際のノード毎に与える重みはどこに保存されているかがわからず困っています。 |
| →直接の値はかかれていないMetaGraphDef protocol bufferの中で復元される認識です（お手上げです） |
| pythonに不慣れなところもあるのですが、困っているのでぜひ答えていただけたら幸いです。 |
| ```` |
| import tensorflow as tf |
| import numpy |
| import os |
| cwd = os.getcwd() |
| SCORE_SIZE = 12 |
| HIDDEN_UNIT_SIZE = 70 |
| TRAIN_DATA_SIZE = 45 |
| raw_input = numpy.loadtxt(open("test.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input, [1]) |
| [tensor_train, tensor_test] = numpy.vsplit(tensor, [TRAIN_DATA_SIZE]) |
| [score_train, score_test] = numpy.vsplit(score, [TRAIN_DATA_SIZE]) |
| def inference(score_placeholder): |
| with tf.name_scope('hidden1') as scope: |
| hidden1_weight = tf.Variable(tf.truncated_normal([SCORE_SIZE, HIDDEN_UNIT_SIZE], stddev=0.1), name="hidden1_weight") |
| hidden1_bias = tf.Variable(tf.constant(0.1, shape=[HIDDEN_UNIT_SIZE]), name="hidden1_bias") |
| hidden1_output = tf.nn.relu(tf.matmul(score_placeholder, hidden1_weight) + hidden1_bias) |
| with tf.name_scope('output') as scope: |
| output_weight = tf.Variable(tf.truncated_normal([HIDDEN_UNIT_SIZE, 1], stddev=0.1), name="output_weight") |
| output_bias = tf.Variable(tf.constant(0.1, shape=[1]), name="output_bias") |
| output = tf.matmul(hidden1_output, output_weight) + output_bias |
| return tf.nn.l2_normalize(output, 0) |
| def loss(output, tensor_placeholder, loss_label_placeholder): |
| with tf.name_scope('loss') as scope: |
| loss = tf.nn.l2_loss(output - tf.nn.l2_normalize(tensor_placeholder, 0)) |
| tf.summary.scalar('loss_label_placeholder', loss) |
| return loss |
| def training(loss): |
| with tf.name_scope('training') as scope: |
| train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss) |
| return train_step |
| with tf.Graph().as_default(): |
| tensor_placeholder = tf.placeholder("float", [None, 1], name="tensor_placeholder") |
| score_placeholder = tf.placeholder("float", [None, SCORE_SIZE], name="score_placeholder") |
| loss_label_placeholder = tf.placeholder("string", name="loss_label_placeholder") |
| feed_dict_train={ |
| tensor_placeholder: tensor_train, |
| score_placeholder: score_train, |
| loss_label_placeholder: "loss_train" |
| } |
| feed_dict_test={ |
| tensor_placeholder: tensor_test, |
| score_placeholder: score_test, |
| loss_label_placeholder: "loss_test" |
| } |
| output = inference(score_placeholder) |
| loss = loss(output, tensor_placeholder, loss_label_placeholder) |
| training_op = training(loss) |
| summary_op = tf.summary.merge_all() |
| init = tf.global_variables_initializer() |
| best_loss = float("inf") |
| with tf.Session() as sess: |
| summary_writer = tf.summary.FileWriter('data', graph_def=sess.graph_def) |
| sess.run(init) |
| for step in range(10000): |
| sess.run(training_op, feed_dict=feed_dict_train) |
| loss_test = sess.run(loss, feed_dict=feed_dict_test) |
| if loss_test < best_loss: |
| best_loss = loss_test |
| best_match = sess.run(output, feed_dict=feed_dict_test) |
| if step % 100 == 0: |
| summary_str = sess.run(summary_op, feed_dict=feed_dict_test) |
| summary_str += sess.run(summary_op, feed_dict=feed_dict_train) |
| summary_writer.add_summary(summary_str, step) |
| saver=tf.train.Saver() |
| saver.save(sess,cwd+'/model.ckpt') |
| print(cwd) |
| print('Saved a model.') |
| sess.close() |
| with tf.Session() as sess2: |
| # 変数の読み込み |
| #新しいデータ |
| raw_input2 = numpy.loadtxt(open("one_record.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input2, [1]) |
| #モデルつくり |
| feed_dict_test2 ={ |
| tensor_placeholder: tensor, |
| score_placeholder: score, |
| loss_label_placeholder: "loss_test" |
| } |
| #復元して、損失関数で定まった、重みをもとに予想を行う関数にいれる |
| saver = tf.train.Saver() |
| cwd = os.getcwd() |
| saver.restore(sess2,cwd + "/model.ckpt") |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| print(best_match2) |
| print("fin") |
| sess2.close() |
| ```` |
| エラーコード |
| ```` |
| Traceback (most recent call last): |
| File "tensor_session.py", line 103, in <module> |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 767, in run |
| run_metadata_ptr) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 944, in _run |
| % (np_val.shape, subfeed_t.name, str(subfeed_t.get_shape()))) |
| ValueError: Cannot feed value of shape (1,) for Tensor 'tensor_placeholder:0', which has shape '(?, 1)' |
| ```` |
zakio49 score 29
2017/07/01 17:52 投稿
| Tensorflow：一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。 |
| 前提・実現したいこと |
| こちらの記事のソースコードを参考にNNを組んで見ました。 |
| 一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。お知恵を拝借したいです。よろしくお願い致します。 |
| ニューラルネットワークでプロ野球選手の給与を査定してみる |
| [http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07](http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07) |
| TensorFlowでmodelを保存して復元する |
| [http://testpy.hatenablog.com/entry/2017/02/02/000000](http://testpy.hatenablog.com/entry/2017/02/02/000000) |
| 実行環境はwindows10+Anaconda+python3.5+tensorflow1.0~になります |
| 現状の理解・躓いていると思っている箇所 |
| *修正7/1 17:02 |
| > 二重誤差の最小値が重要ではなくて、重みとバイアスが重要であることがよくわかりました。model.ckpt.metaファイルに特別重みがの値が書かれていなかったので、二重誤差の値が重要だと勘違いしていました。制御コードが埋め込まれている |
| 色々な点を修正させていただき新たな疑問として |
| 復元したモデルを再利用する流れについては |
| 1.変数の読み込み(csvファイル) |
| 2.使えるデータ形式に変化（） |
| 3.学習したときに使ったinterface(score_placeholder)で使える形にモデルを作る |
| 4.meta.ckptを復元して、重みをもとに予想を行う関数(interface)にいれる |
| 5,sess.runを行い予想値をプリントする。 |
| ↓によると MetaGraphDef protocol buffer.がmodel.ckpt.metaファイルをもとにプロセスを復元するから、重みの値はその中で復元されるから、直接は書いてないよという理解をしました。 |
| > 二重誤差の最小値が重要ではなくて、重みとバイアスが重要であることがよくわかりました。model.ckpt.metaファイルにそれぞれのリンクの重みの値が書かれていなかったので、二重誤差の値から復元できると勘違いしていました。 |
| ↓結局、model.ckpt.metaはブラックボックスのままなのですが（制御コードとか埋め込まれており）リンクによると MetaGraphDef protocol buffer.がmodel.ckpt.metaファイルをもとにプロセスを復元するから、重みの値はその中で復元されるから、直接は書いてないよという理解をしました。 |
| What is the TensorFlow checkpoint meta file? |
| [https://stackoverflow.com/questions/36195454/what-is-the-tensorflow-checkpoint-meta-file/36203288#36203288](https://stackoverflow.com/questions/36195454/what-is-the-tensorflow-checkpoint-meta-file/36203288#36203288) |
| ニューラルネットワークの流れというか保持・復元のしていること |
| 1,出力層の出力 |
| ニューラルネットワークの流れというか保持・復元のしていること（修正） |
| 1,出力層の出力値が教師データに近づいてるのかを表す尺度として損失関数を重みやバイアスで指定した回数（10000回）偏微分を行い。2乗誤差 Eをを小さくしようとする。 |
| 2,その時の重み、ベクトル量を保持する。 |
| *誤差逆伝播法の理解に誤りがありました、入力ノードから次の層へのリンク一つ一つにランダムで割り当てられた重みがつき、それらの和がシグモイド関数orReLU関数に入力されて次の層のノードに入力され、行きついた値と教師データの値との間の誤差をみて、重みを変化させるフィードバックを与えるという理解をしています。 |
| このままだとプログラムの誤差が最小の値を保持していても、復元した際のノード毎に与える重みはどこに保存されているかがわからず困っています。 |
| →直接の値はかかれていないMetaGraphDef protocol bufferの中で復元される認識です（お手上げです） |
| pythonに不慣れなところもあるのですが、困っているのでぜひ答えていただけたら幸いです。 |
| ```` |
| import tensorflow as tf |
| import numpy |
| import os |
| cwd = os.getcwd() |
| SCORE_SIZE = 12 |
| HIDDEN_UNIT_SIZE = 70 |
| TRAIN_DATA_SIZE = 45 |
| raw_input = numpy.loadtxt(open("test.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input, [1]) |
| [tensor_train, tensor_test] = numpy.vsplit(tensor, [TRAIN_DATA_SIZE]) |
| [score_train, score_test] = numpy.vsplit(score, [TRAIN_DATA_SIZE]) |
| def inference(score_placeholder): |
| with tf.name_scope('hidden1') as scope: |
| hidden1_weight = tf.Variable(tf.truncated_normal([SCORE_SIZE, HIDDEN_UNIT_SIZE], stddev=0.1), name="hidden1_weight") |
| hidden1_bias = tf.Variable(tf.constant(0.1, shape=[HIDDEN_UNIT_SIZE]), name="hidden1_bias") |
| hidden1_output = tf.nn.relu(tf.matmul(score_placeholder, hidden1_weight) + hidden1_bias) |
| with tf.name_scope('output') as scope: |
| output_weight = tf.Variable(tf.truncated_normal([HIDDEN_UNIT_SIZE, 1], stddev=0.1), name="output_weight") |
| output_bias = tf.Variable(tf.constant(0.1, shape=[1]), name="output_bias") |
| output = tf.matmul(hidden1_output, output_weight) + output_bias |
| return tf.nn.l2_normalize(output, 0) |
| def loss(output, tensor_placeholder, loss_label_placeholder): |
| with tf.name_scope('loss') as scope: |
| loss = tf.nn.l2_loss(output - tf.nn.l2_normalize(tensor_placeholder, 0)) |
| tf.summary.scalar('loss_label_placeholder', loss) |
| return loss |
| def training(loss): |
| with tf.name_scope('training') as scope: |
| train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss) |
| return train_step |
| with tf.Graph().as_default(): |
| tensor_placeholder = tf.placeholder("float", [None, 1], name="tensor_placeholder") |
| score_placeholder = tf.placeholder("float", [None, SCORE_SIZE], name="score_placeholder") |
| loss_label_placeholder = tf.placeholder("string", name="loss_label_placeholder") |
| feed_dict_train={ |
| tensor_placeholder: tensor_train, |
| score_placeholder: score_train, |
| loss_label_placeholder: "loss_train" |
| } |
| feed_dict_test={ |
| tensor_placeholder: tensor_test, |
| score_placeholder: score_test, |
| loss_label_placeholder: "loss_test" |
| } |
| output = inference(score_placeholder) |
| loss = loss(output, tensor_placeholder, loss_label_placeholder) |
| training_op = training(loss) |
| summary_op = tf.summary.merge_all() |
| init = tf.global_variables_initializer() |
| best_loss = float("inf") |
| with tf.Session() as sess: |
| summary_writer = tf.summary.FileWriter('data', graph_def=sess.graph_def) |
| sess.run(init) |
| for step in range(10000): |
| sess.run(training_op, feed_dict=feed_dict_train) |
| loss_test = sess.run(loss, feed_dict=feed_dict_test) |
| if loss_test < best_loss: |
| best_loss = loss_test |
| best_match = sess.run(output, feed_dict=feed_dict_test) |
| if step % 100 == 0: |
| summary_str = sess.run(summary_op, feed_dict=feed_dict_test) |
| summary_str += sess.run(summary_op, feed_dict=feed_dict_train) |
| summary_writer.add_summary(summary_str, step) |
| saver=tf.train.Saver() |
| saver.save(sess,cwd+'/model.ckpt') |
| print(cwd) |
| print('Saved a model.') |
| sess.close() |
| with tf.Session() as sess2: |
| # 変数の読み込み |
| #新しいデータ |
| raw_input2 = numpy.loadtxt(open("one_record.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input2, [1]) |
| #モデルつくり |
| feed_dict_test2 ={ |
| tensor_placeholder: tensor, |
| score_placeholder: score, |
| loss_label_placeholder: "loss_test" |
| } |
| #復元して、損失関数で定まった、重みをもとに予想を行う関数にいれる |
| saver = tf.train.Saver() |
| cwd = os.getcwd() |
| saver.restore(sess2,cwd + "/model.ckpt") |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| print(best_match2) |
| print("fin") |
| sess2.close() |
| ```` |
| エラーコード |
| ```` |
| Traceback (most recent call last): |
| File "tensor_session.py", line 103, in <module> |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 767, in run |
| run_metadata_ptr) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 944, in _run |
| % (np_val.shape, subfeed_t.name, str(subfeed_t.get_shape()))) |
| ValueError: Cannot feed value of shape (1,) for Tensor 'tensor_placeholder:0', which has shape '(?, 1)' |
| ```` |
zakio49 score 29
2017/07/01 17:35 投稿
| Tensorflow：一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。 |
| 前提・実現したいこと |
| こちらの記事のソースコードを参考にNNを組んで見ました。 |
| 一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。お知恵を拝借したいです。よろしくお願い致します。 |
| ニューラルネットワークでプロ野球選手の給与を査定してみる |
| [http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07](http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07) |
| TensorFlowでmodelを保存して復元する |
| [http://testpy.hatenablog.com/entry/2017/02/02/000000](http://testpy.hatenablog.com/entry/2017/02/02/000000) |
| 実行環境はwindows10+Anaconda+python3.5+tensorflow1.0~になります |
| 現状の理解・躓いていると思っている箇所 |
| *修正7/1 17:02 |
| > 二重誤差の最小値が重要ではなくて、重みとバイアスが重要であることがよくわかりました。model.ckpt.metaファイルに特別重みがの値が書かれていなかったので、二重誤差の値が重要だと勘違いしていました。制御コードが埋め込まれている |
| ↓によると MetaGraphDef protocol buffer.がmodel.ckpt.metaファイルをもとにプロセスを復元するから、重みの値はその中で復元されるから、直接は書いてないよという理解をしました。 |
| What is the TensorFlow checkpoint meta file? |
| [https://stackoverflow.com/questions/36195454/what-is-the-tensorflow-checkpoint-meta-file/36203288#36203288](https://stackoverflow.com/questions/36195454/what-is-the-tensorflow-checkpoint-meta-file/36203288#36203288) |
| ニューラルネットワークの流れというか保持・復元のしていること |
| 1,出力層の出力が教師データに近づいてるのかを表す尺度として |
| 1,出力層の出力が教師データに近づいてるのかを表す尺度として損失関数を重みやバイアスの変数で微分（偏微分）し2乗誤差 Eをを小さくする指定した今回は10000回） |
| 2,その時の重み、ベクトル量を保持する。 |
| 3,新たな入力（ |
| 3,新たな入力（実践データ）に対して、保持された重みとバイアス用いて入力と重みとバイアスの値からどう推定するか定めた関数に入れることで（今回は**inference(score_placeholder)**）適当な値が予想できると思っています。 |
| *誤差逆伝播法の理解に誤りがありました、入力ノードから次の層へのリンク一つ一つにランダムで割り当てられた重みがつき、それらの和がシグモイド関数orReLU関数に入力されて次の層のノードに入力され、行きついた値と教師データの値との間の誤差をみて、重みを変化させるフィードバックを与えるという理解をしています。 |
| このままだとプログラムの誤差が最小の値を保持していても、復元した際のノード毎に与える重みはどこに保存されているかがわからず困っています。 |
| pythonに不慣れなところもあるのですが、困っているのでぜひ答えていただけたら幸いです。 |
| ```` |
| import tensorflow as tf |
| import numpy |
| import os |
| cwd = os.getcwd() |
| SCORE_SIZE = 12 |
| HIDDEN_UNIT_SIZE = 70 |
| TRAIN_DATA_SIZE = 45 |
| raw_input = numpy.loadtxt(open("test.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input, [1]) |
| [tensor_train, tensor_test] = numpy.vsplit(tensor, [TRAIN_DATA_SIZE]) |
| [score_train, score_test] = numpy.vsplit(score, [TRAIN_DATA_SIZE]) |
| def inference(score_placeholder): |
| with tf.name_scope('hidden1') as scope: |
| hidden1_weight = tf.Variable(tf.truncated_normal([SCORE_SIZE, HIDDEN_UNIT_SIZE], stddev=0.1), name="hidden1_weight") |
| hidden1_bias = tf.Variable(tf.constant(0.1, shape=[HIDDEN_UNIT_SIZE]), name="hidden1_bias") |
| hidden1_output = tf.nn.relu(tf.matmul(score_placeholder, hidden1_weight) + hidden1_bias) |
| with tf.name_scope('output') as scope: |
| output_weight = tf.Variable(tf.truncated_normal([HIDDEN_UNIT_SIZE, 1], stddev=0.1), name="output_weight") |
| output_bias = tf.Variable(tf.constant(0.1, shape=[1]), name="output_bias") |
| output = tf.matmul(hidden1_output, output_weight) + output_bias |
| return tf.nn.l2_normalize(output, 0) |
| def loss(output, tensor_placeholder, loss_label_placeholder): |
| with tf.name_scope('loss') as scope: |
| loss = tf.nn.l2_loss(output - tf.nn.l2_normalize(tensor_placeholder, 0)) |
| tf.summary.scalar('loss_label_placeholder', loss) |
| return loss |
| def training(loss): |
| with tf.name_scope('training') as scope: |
| train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss) |
| return train_step |
| with tf.Graph().as_default(): |
| tensor_placeholder = tf.placeholder("float", [None, 1], name="tensor_placeholder") |
| score_placeholder = tf.placeholder("float", [None, SCORE_SIZE], name="score_placeholder") |
| loss_label_placeholder = tf.placeholder("string", name="loss_label_placeholder") |
| feed_dict_train={ |
| tensor_placeholder: tensor_train, |
| score_placeholder: score_train, |
| loss_label_placeholder: "loss_train" |
| } |
| feed_dict_test={ |
| tensor_placeholder: tensor_test, |
| score_placeholder: score_test, |
| loss_label_placeholder: "loss_test" |
| } |
| output = inference(score_placeholder) |
| loss = loss(output, tensor_placeholder, loss_label_placeholder) |
| training_op = training(loss) |
| summary_op = tf.summary.merge_all() |
| init = tf.global_variables_initializer() |
| best_loss = float("inf") |
| with tf.Session() as sess: |
| summary_writer = tf.summary.FileWriter('data', graph_def=sess.graph_def) |
| sess.run(init) |
| for step in range(10000): |
| sess.run(training_op, feed_dict=feed_dict_train) |
| loss_test = sess.run(loss, feed_dict=feed_dict_test) |
| if loss_test < best_loss: |
| best_loss = loss_test |
| best_match = sess.run(output, feed_dict=feed_dict_test) |
| if step % 100 == 0: |
| summary_str = sess.run(summary_op, feed_dict=feed_dict_test) |
| summary_str += sess.run(summary_op, feed_dict=feed_dict_train) |
| summary_writer.add_summary(summary_str, step) |
| saver=tf.train.Saver() |
| saver.save(sess,cwd+'/model.ckpt') |
| print(cwd) |
| print('Saved a model.') |
| sess.close() |
| with tf.Session() as sess2: |
| # 変数の読み込み |
| #新しいデータ |
| raw_input2 = numpy.loadtxt(open("one_record.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input2, [1]) |
| #モデルつくり |
| feed_dict_test2 ={ |
| tensor_placeholder: tensor, |
| score_placeholder: score, |
| loss_label_placeholder: "loss_test" |
| } |
| #復元して、損失関数で定まった、重みをもとに予想を行う関数にいれる |
| saver = tf.train.Saver() |
| cwd = os.getcwd() |
| saver.restore(sess2,cwd + "/model.ckpt") |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| print(best_match2) |
| print("fin") |
| sess2.close() |
| ```` |
| エラーコード |
| ```` |
| Traceback (most recent call last): |
| File "tensor_session.py", line 103, in <module> |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 767, in run |
| run_metadata_ptr) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 944, in _run |
| % (np_val.shape, subfeed_t.name, str(subfeed_t.get_shape()))) |
| ValueError: Cannot feed value of shape (1,) for Tensor 'tensor_placeholder:0', which has shape '(?, 1)' |
| ```` |
zakio49 score 29
2017/07/01 17:20 投稿
| Tensorflow：一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。 |
| 前提・実現したいこと |
| こちらの記事のソースコードを参考にNNを組んで見ました。 |
| 一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。お知恵を拝借したいです。よろしくお願い致します。 |
| ニューラルネットワークでプロ野球選手の給与を査定してみる |
| http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07 |
| TensorFlowでmodelを保存して復元する |
| http://testpy.hatenablog.com/entry/2017/02/02/000000 |
| 実行環境はwindows10+Anaconda+python3.5+tensorflow1.0~になります |
| 現状の理解・躓いていると思っている箇所 |
| *修正7/1 17:02 |
| ニューラルネットワークの流れというか保持・復元のしていること |
| 1,出力層の出力が教師 |
| 3,新たな入力 |
| 1,出力層の出力が教師データに近づいてるのかを表す尺度として2乗誤差 Eがもっとも小さい値を求める（指定した今回は10000回） |
| 3,新たな入力（践データ）に対して、定められた重さと二乗誤差を用いてoutput()を通ることで適当な値が予想できると思っています。 |
| *誤差逆伝播法の理解に誤りがありました、入力ノードの一つ一つにランダムで割り当てられた重さがつき、それらの和がジグモイドorRuLA関数に入力されて次の層のノードに入力され、行きついた値と教師データの値との間の誤差をみて、重みを変化させるフィードバックを与えるという理解をしています。 |
| *誤差逆伝播法の理解に誤りがありました、入力ノードから次の層へのリンク一つ一つにランダムで割り当てられた重みがつき、それらの和がシグモイド関数orReLU関数に入力されて次の層のノードに入力され、行きついた値と教師データの値との間の誤差をみて、重みを変化させるフィードバックを与えるという理解をしています。 |
| このままだとプログラムの誤差が最小の値を保持していても、復元した際のノード毎に与える重みはどこに保存されているかがわからず困っています。 |
| pythonに不慣れなところもあるのですが、困っているのでぜひ答えていただけたら幸いです。 |
| ```` |
| import tensorflow as tf |
| import numpy |
| import os |
| cwd = os.getcwd() |
| SCORE_SIZE = 12 |
| HIDDEN_UNIT_SIZE = 70 |
| TRAIN_DATA_SIZE = 45 |
| raw_input = numpy.loadtxt(open("test.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input, [1]) |
| [tensor_train, tensor_test] = numpy.vsplit(tensor, [TRAIN_DATA_SIZE]) |
| [score_train, score_test] = numpy.vsplit(score, [TRAIN_DATA_SIZE]) |
| def inference(score_placeholder): |
| with tf.name_scope('hidden1') as scope: |
| hidden1_weight = tf.Variable(tf.truncated_normal([SCORE_SIZE, HIDDEN_UNIT_SIZE], stddev=0.1), name="hidden1_weight") |
| hidden1_bias = tf.Variable(tf.constant(0.1, shape=[HIDDEN_UNIT_SIZE]), name="hidden1_bias") |
| hidden1_output = tf.nn.relu(tf.matmul(score_placeholder, hidden1_weight) + hidden1_bias) |
| with tf.name_scope('output') as scope: |
| output_weight = tf.Variable(tf.truncated_normal([HIDDEN_UNIT_SIZE, 1], stddev=0.1), name="output_weight") |
| output_bias = tf.Variable(tf.constant(0.1, shape=[1]), name="output_bias") |
| output = tf.matmul(hidden1_output, output_weight) + output_bias |
| return tf.nn.l2_normalize(output, 0) |
| def loss(output, tensor_placeholder, loss_label_placeholder): |
| with tf.name_scope('loss') as scope: |
| loss = tf.nn.l2_loss(output - tf.nn.l2_normalize(tensor_placeholder, 0)) |
| tf.summary.scalar('loss_label_placeholder', loss) |
| return loss |
| def training(loss): |
| with tf.name_scope('training') as scope: |
| train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss) |
| return train_step |
| with tf.Graph().as_default(): |
| tensor_placeholder = tf.placeholder("float", [None, 1], name="tensor_placeholder") |
| score_placeholder = tf.placeholder("float", [None, SCORE_SIZE], name="score_placeholder") |
| loss_label_placeholder = tf.placeholder("string", name="loss_label_placeholder") |
| feed_dict_train={ |
| tensor_placeholder: tensor_train, |
| score_placeholder: score_train, |
| loss_label_placeholder: "loss_train" |
| } |
| feed_dict_test={ |
| tensor_placeholder: tensor_test, |
| score_placeholder: score_test, |
| loss_label_placeholder: "loss_test" |
| } |
| output = inference(score_placeholder) |
| loss = loss(output, tensor_placeholder, loss_label_placeholder) |
| training_op = training(loss) |
| summary_op = tf.summary.merge_all() |
| init = tf.global_variables_initializer() |
| best_loss = float("inf") |
| with tf.Session() as sess: |
| summary_writer = tf.summary.FileWriter('data', graph_def=sess.graph_def) |
| sess.run(init) |
| for step in range(10000): |
| sess.run(training_op, feed_dict=feed_dict_train) |
| loss_test = sess.run(loss, feed_dict=feed_dict_test) |
| if loss_test < best_loss: |
| best_loss = loss_test |
| best_match = sess.run(output, feed_dict=feed_dict_test) |
| if step % 100 == 0: |
| summary_str = sess.run(summary_op, feed_dict=feed_dict_test) |
| summary_str += sess.run(summary_op, feed_dict=feed_dict_train) |
| summary_writer.add_summary(summary_str, step) |
| saver=tf.train.Saver() |
| saver.save(sess,cwd+'/model.ckpt') |
| print(cwd) |
| print('Saved a model.') |
| sess.close() |
| with tf.Session() as sess2: |
| # 変数の読み込み |
| #新しいデータ |
| raw_input2 = numpy.loadtxt(open("one_record.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input2, [1]) |
| #モデルつくり |
| feed_dict_test2 ={ |
| tensor_placeholder: tensor, |
| score_placeholder: score, |
| loss_label_placeholder: "loss_test" |
| } |
| #復元して、損失関数で定まった、重みをもとに予想を行う関数にいれる |
| saver = tf.train.Saver() |
| cwd = os.getcwd() |
| saver.restore(sess2,cwd + "/model.ckpt") |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| print(best_match2) |
| print("fin") |
| sess2.close() |
| ```` |
| エラーコード |
| ```` |
| Traceback (most recent call last): |
| File "tensor_session.py", line 103, in <module> |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 767, in run |
| run_metadata_ptr) |
| File "C:\Users\takkun\Anaconda3\envs\tensorenv\lib\site-packages\tensorflow\python\client\session.py", line 944, in _run |
| % (np_val.shape, subfeed_t.name, str(subfeed_t.get_shape()))) |
| ValueError: Cannot feed value of shape (1,) for Tensor 'tensor_placeholder:0', which has shape '(?, 1)' |
| ```` |
zakio49 score 29
2017/07/01 17:10 投稿
| Tensorflow：一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。 |
| 前提・実現したいこと |
| こちらの記事のソースコードを参考にNNを組んで見ました。 |
| 一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。お知恵を拝借したいです。よろしくお願い致します。 |
| ニューラルネットワークでプロ野球選手の給与を査定してみる |
| http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07 |
| TensorFlowでmodelを保存して復元する |
| http://testpy.hatenablog.com/entry/2017/02/02/000000 |
| 実行環境はwindows10+Anaconda+python3.5+tensorflow1.0~になります |
| 現状の理解・躓いていると思っている箇所 |
| ニューラルネットワークの流れというか保持・復元のしていること |
| 1,出力層の出力が教師信号に近づいてるのかを表す尺度として2乗誤差 Eがもっとも小さい値を保持する。 |
| 2,その時の重さは 2乗誤差 Eから復元できる？ |
| 3,新たな入力に対して、定められた重さと二乗誤差を用いてoutput()を通ることで適当な値が予想できると思っています。 |
| *誤差逆伝播法の理解に誤りがありました、入力ノードの一つ一つにランダムで割り当てられた重さがつき、それらの和がジグモイドorRuLA関数に入力されて次の層のノードに入力され、行きついた値と教師データの値との間の誤差をみて、重みを変化させるフィードバックを与えるという理解をしています。 |
| このままだとプログラムの誤差が最小の値を保持していても、復元した際のノード毎に与える重みはどこに保存されているかがわからず困っています。 |
| pythonに不慣れなところもあるのですが、困っているのでぜひ答えていただけたら幸いです。 |
| ```` |
| import tensorflow as tf |
| import numpy |
| import os |
| cwd = os.getcwd() |
| SCORE_SIZE = 12 |
| HIDDEN_UNIT_SIZE = 70 |
| TRAIN_DATA_SIZE = 45 |
| raw_input = numpy.loadtxt(open("test.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input, [1]) |
| [tensor_train, tensor_test] = numpy.vsplit(tensor, [TRAIN_DATA_SIZE]) |
| [score_train, score_test] = numpy.vsplit(score, [TRAIN_DATA_SIZE]) |
| def inference(score_placeholder): |
| with tf.name_scope('hidden1') as scope: |
| hidden1_weight = tf.Variable(tf.truncated_normal([SCORE_SIZE, HIDDEN_UNIT_SIZE], stddev=0.1), name="hidden1_weight") |
| hidden1_bias = tf.Variable(tf.constant(0.1, shape=[HIDDEN_UNIT_SIZE]), name="hidden1_bias") |
| hidden1_output = tf.nn.relu(tf.matmul(score_placeholder, hidden1_weight) + hidden1_bias) |
| with tf.name_scope('output') as scope: |
| output_weight = tf.Variable(tf.truncated_normal([HIDDEN_UNIT_SIZE, 1], stddev=0.1), name="output_weight") |
| output_bias = tf.Variable(tf.constant(0.1, shape=[1]), name="output_bias") |
| output = tf.matmul(hidden1_output, output_weight) + output_bias |
| return tf.nn.l2_normalize(output, 0) |
| def loss(output, tensor_placeholder, loss_label_placeholder): |
| with tf.name_scope('loss') as scope: |
| loss = tf.nn.l2_loss(output - tf.nn.l2_normalize(tensor_placeholder, 0)) |
| tf.summary.scalar('loss_label_placeholder', loss) |
| return loss |
| def training(loss): |
| with tf.name_scope('training') as scope: |
| train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss) |
| return train_step |
| with tf.Graph().as_default(): |
| tensor_placeholder = tf.placeholder("float", [None, 1], name="tensor_placeholder") |
| score_placeholder = tf.placeholder("float", [None, SCORE_SIZE], name="score_placeholder") |
| loss_label_placeholder = tf.placeholder("string", name="loss_label_placeholder") |
| feed_dict_train={ |
| tensor_placeholder: tensor_train, |
| score_placeholder: score_train, |
| loss_label_placeholder: "loss_train" |
| } |
| feed_dict_test={ |
| tensor_placeholder: tensor_test, |
| score_placeholder: score_test, |
| loss_label_placeholder: "loss_test" |
| } |
| output = inference(score_placeholder) |
| loss = loss(output, tensor_placeholder, loss_label_placeholder) |
| training_op = training(loss) |
| summary_op = tf.summary.merge_all() |
| init = tf.global_variables_initializer() |
| best_loss = float("inf") |
| with tf.Session() as sess: |
| summary_writer = tf.summary.FileWriter('data', graph_def=sess.graph_def) |
| sess.run(init) |
| for step in range(10000): |
| sess.run(training_op, feed_dict=feed_dict_train) |
| loss_test = sess.run(loss, feed_dict=feed_dict_test) |
| if loss_test < best_loss: |
| best_loss = loss_test |
| best_match = sess.run(output, feed_dict=feed_dict_test) |
| if step % 100 == 0: |
| summary_str = sess.run(summary_op, feed_dict=feed_dict_test) |
| summary_str += sess.run(summary_op, feed_dict=feed_dict_train) |
| summary_writer.add_summary(summary_str, step) |
| saver=tf.train.Saver() |
| saver.save(sess,cwd+' |
| saver.save(sess,cwd+'/model.ckpt') |
| print(cwd) |
| print('Saved a model.') |
| sess.close() |
| with tf.Session() as sess2: |
| # 変数の読み込み |
| |
| raw_input2 = numpy.loadtxt(open(" |
| #新しいデータ |
| raw_input2 = numpy.loadtxt(open("one_record.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input2, [1]) |
| |
| feed_dict_test2 |
| #モデルつくり |
| feed_dict_test2 ={ |
| tensor_placeholder: tensor, |
| score_placeholder: score, |
| loss_label_placeholder: "loss_test" |
| } |
| |
| #復元して、損失関数で定まった、重みをもとに予想を行う関数にいれる |
| saver = tf.train.Saver() |
| cwd = os.getcwd() |
| saver.restore(sess2,cwd + "/model.ckpt") |
| best_match2 = sess2.run(output, feed_dict=feed_dict_test2) |
| prediction = tf.argmax(new_data,None) |
| best_match2 = sess2.run(inference, feed_dict=feed_dict_test2) |
| print(best_match2) |
| print("fin") |
| |
| sess2.close() |
| ```` |
zakio49 score 29
2017/07/01 06:35 投稿
| Tensorflow：一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。 |
| 前提・実現したいこと |
| こちらの記事のソースコードを参考にNNを組んで見ました。 |
| 一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。お知恵を拝借したいです。よろしくお願い致します。 |
| ニューラルネットワークでプロ野球選手の給与を査定してみる |
| http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07 |
| TensorFlowでmodelを保存して復元する |
| http://testpy.hatenablog.com/entry/2017/02/02/000000 |
| 実行環境はwindows10+Anaconda+python3.5+tensorflow1.0~になります |
| 現状の理解・躓いていると思っている箇所 |
| ニューラルネットワークの流れというか保持・復元のしていること |
| 1,出力層の出力が教師信号に近づいてるのかを表す尺度として2乗誤差 Eがもっとも小さい値を保持する。 |
| 2,その時の重さは 2乗誤差 Eから復元できる？ |
| 3,新たな入力に対して、定められた重さと二乗誤差を用いてoutput()を通ることで適当な値が予想できると思っています。 |
| *誤差逆伝播法の理解に誤りがありました、入力ノードの一つ一つにランダムで割り当てられた重さがつき、それらの和がジグモイドorRuLA関数に入力されて次の層のノードに入力され、行きついた値と教師データの値との間の誤差をみて、重みを変化させるフィードバックを与えるという理解をしています。 |
| このままだとプログラムの誤差が最小の値を保持していても、復元した際のノード毎に与える重みはどこに保存されているかがわからず困っています。 |
| pythonに不慣れなところもあるのですが、困っているのでぜひ答えていただけたら幸いです。 |
| ```` |
| import tensorflow as tf |
| import numpy |
| import os |
| cwd = os.getcwd() |
| SCORE_SIZE = 12 |
| HIDDEN_UNIT_SIZE = 70 |
| TRAIN_DATA_SIZE = 45 |
| raw_input = numpy.loadtxt(open("test.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input, [1]) |
| [tensor_train, tensor_test] = numpy.vsplit(tensor, [TRAIN_DATA_SIZE]) |
| [score_train, score_test] = numpy.vsplit(score, [TRAIN_DATA_SIZE]) |
| def inference(score_placeholder): |
| with tf.name_scope('hidden1') as scope: |
| hidden1_weight = tf.Variable(tf.truncated_normal([SCORE_SIZE, HIDDEN_UNIT_SIZE], stddev=0.1), name="hidden1_weight") |
| hidden1_bias = tf.Variable(tf.constant(0.1, shape=[HIDDEN_UNIT_SIZE]), name="hidden1_bias") |
| hidden1_output = tf.nn.relu(tf.matmul(score_placeholder, hidden1_weight) + hidden1_bias) |
| with tf.name_scope('output') as scope: |
| output_weight = tf.Variable(tf.truncated_normal([HIDDEN_UNIT_SIZE, 1], stddev=0.1), name="output_weight") |
| output_bias = tf.Variable(tf.constant(0.1, shape=[1]), name="output_bias") |
| output = tf.matmul(hidden1_output, output_weight) + output_bias |
| return tf.nn.l2_normalize(output, 0) |
| def loss(output, tensor_placeholder, loss_label_placeholder): |
| with tf.name_scope('loss') as scope: |
| loss = tf.nn.l2_loss(output - tf.nn.l2_normalize(tensor_placeholder, 0)) |
| tf.summary.scalar('loss_label_placeholder', loss) |
| return loss |
| def training(loss): |
| with tf.name_scope('training') as scope: |
| train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss) |
| return train_step |
| with tf.Graph().as_default(): |
| tensor_placeholder = tf.placeholder("float", [None, 1], name="tensor_placeholder") |
| score_placeholder = tf.placeholder("float", [None, SCORE_SIZE], name="score_placeholder") |
| loss_label_placeholder = tf.placeholder("string", name="loss_label_placeholder") |
| feed_dict_train={ |
| tensor_placeholder: tensor_train, |
| score_placeholder: score_train, |
| loss_label_placeholder: "loss_train" |
| } |
| feed_dict_test={ |
| tensor_placeholder: tensor_test, |
| score_placeholder: score_test, |
| loss_label_placeholder: "loss_test" |
| } |
| output = inference(score_placeholder) |
| loss = loss(output, tensor_placeholder, loss_label_placeholder) |
| training_op = training(loss) |
| summary_op = tf.summary.merge_all() |
| init = tf.global_variables_initializer() |
| best_loss = float("inf") |
| with tf.Session() as sess: |
| summary_writer = tf.summary.FileWriter('data', graph_def=sess.graph_def) |
| sess.run(init) |
| for step in range(10000): |
| sess.run(training_op, feed_dict=feed_dict_train) |
| loss_test = sess.run(loss, feed_dict=feed_dict_test) |
| if loss_test < best_loss: |
| best_loss = loss_test |
| best_match = sess.run(output, feed_dict=feed_dict_test) |
| if step % 100 == 0: |
| summary_str = sess.run(summary_op, feed_dict=feed_dict_test) |
| summary_str += sess.run(summary_op, feed_dict=feed_dict_train) |
| summary_writer.add_summary(summary_str, step) |
| saver=tf.train.Saver() |
| saver.save(sess,cwd+'model.ckpt',global_step=100) |
| print('Saved a model.') |
| sess.close() |
| #ここからが復元するコードです。 |
| with tf.Session() as sess2: |
| # 変数の読み込み |
| #新しいデータ |
| raw_input2 = numpy.loadtxt(open("new_data.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input2, [1]) |
| #モデルつくり |
| feed_dict_test2={ |
| tensor_placeholder: tensor, |
| score_placeholder: score, |
| loss_label_placeholder: "loss_test" |
| } |
| #復元して、学習して得られた損失関数の値を使って、新しく読み込んだ値から予想値を計算するようにoutput関数にくぐらせる |
| saver = tf.train.Saver() |
| cwd = os.getcwd() |
| saver.restore(sess2,cwd + "/model.ckpt") |
| best_match2 = sess2.run(output, feed_dict=feed_dict_test2) |
| prediction = tf.argmax(new_data,None) |
| print(best_match2) |
| print("fin") |
| resess.close() |
| ```` |
zakio49 score 29
2017/07/01 06:19 投稿
| Tensorflow：一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。 |
| 前提・実現したいこと |
| こちらの記事のソースコードを参考にNNを組んで見ました。 |
| 一度学習したものの損失関数の値を保持・復元して、新たな入力に対して予測を行いたいです。お知恵を拝借したいです。よろしくお願い致します。 |
| ニューラルネットワークでプロ野球選手の給与を査定してみる |
| http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07 |
| TensorFlowでmodelを保存して復元する |
| http://testpy.hatenablog.com/entry/2017/02/02/000000 |
| 実行環境はwindows10+Anaconda+python3.5+tensorflow1.0~になります |
| 現状の理解・躓いていると思っている箇所 |
| ニューラルネットワークの流れというか保持・復元のしていること |
| 1,出力層の出力が教師信号に近づいてるのかを表す尺度として2乗誤差 Eがもっとも小さい値を保持する。 |
| 2,その時の重さは 2乗誤差 Eから復元できる？ |
| 3,新たな入力に対して、定められた重さと二乗誤差を用いてoutput()を通ることで適当な値が予想できると思っています。 |
| pythonに不慣れなところもあるのですが、困っているのでぜひ答えていただけたら幸いです。 |
| ```` |
| import tensorflow as tf |
| import numpy |
| import os |
| cwd = os.getcwd() |
| SCORE_SIZE = 12 |
| HIDDEN_UNIT_SIZE = 70 |
| TRAIN_DATA_SIZE = 45 |
| raw_input = numpy.loadtxt(open("test.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input, [1]) |
| [tensor_train, tensor_test] = numpy.vsplit(tensor, [TRAIN_DATA_SIZE]) |
| [score_train, score_test] = numpy.vsplit(score, [TRAIN_DATA_SIZE]) |
| def inference(score_placeholder): |
| with tf.name_scope('hidden1') as scope: |
| hidden1_weight = tf.Variable(tf.truncated_normal([SCORE_SIZE, HIDDEN_UNIT_SIZE], stddev=0.1), name="hidden1_weight") |
| hidden1_bias = tf.Variable(tf.constant(0.1, shape=[HIDDEN_UNIT_SIZE]), name="hidden1_bias") |
| hidden1_output = tf.nn.relu(tf.matmul(score_placeholder, hidden1_weight) + hidden1_bias) |
| with tf.name_scope('output') as scope: |
| output_weight = tf.Variable(tf.truncated_normal([HIDDEN_UNIT_SIZE, 1], stddev=0.1), name="output_weight") |
| output_bias = tf.Variable(tf.constant(0.1, shape=[1]), name="output_bias") |
| output = tf.matmul(hidden1_output, output_weight) + output_bias |
| return tf.nn.l2_normalize(output, 0) |
| def loss(output, tensor_placeholder, loss_label_placeholder): |
| with tf.name_scope('loss') as scope: |
| loss = tf.nn.l2_loss(output - tf.nn.l2_normalize(tensor_placeholder, 0)) |
| tf.summary.scalar('loss_label_placeholder', loss) |
| return loss |
| def training(loss): |
| with tf.name_scope('training') as scope: |
| train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss) |
| return train_step |
| with tf.Graph().as_default(): |
| tensor_placeholder = tf.placeholder("float", [None, 1], name="tensor_placeholder") |
| score_placeholder = tf.placeholder("float", [None, SCORE_SIZE], name="score_placeholder") |
| loss_label_placeholder = tf.placeholder("string", name="loss_label_placeholder") |
| feed_dict_train={ |
| tensor_placeholder: tensor_train, |
| score_placeholder: score_train, |
| loss_label_placeholder: "loss_train" |
| } |
| feed_dict_test={ |
| tensor_placeholder: tensor_test, |
| score_placeholder: score_test, |
| loss_label_placeholder: "loss_test" |
| } |
| output = inference(score_placeholder) |
| loss = loss(output, tensor_placeholder, loss_label_placeholder) |
| training_op = training(loss) |
| summary_op = tf.summary.merge_all() |
| init = tf.global_variables_initializer() |
| best_loss = float("inf") |
| with tf.Session() as sess: |
| summary_writer = tf.summary.FileWriter('data', graph_def=sess.graph_def) |
| sess.run(init) |
| for step in range(10000): |
| sess.run(training_op, feed_dict=feed_dict_train) |
| loss_test = sess.run(loss, feed_dict=feed_dict_test) |
| if loss_test < best_loss: |
| best_loss = loss_test |
| best_match = sess.run(output, feed_dict=feed_dict_test) |
| if step % 100 == 0: |
| summary_str = sess.run(summary_op, feed_dict=feed_dict_test) |
| summary_str += sess.run(summary_op, feed_dict=feed_dict_train) |
| summary_writer.add_summary(summary_str, step) |
| saver=tf.train.Saver() |
| saver.save(sess,cwd+'model.ckpt',global_step=100) |
| print('Saved a model.') |
| sess.close() |
| #ここからが復元するコードです。 |
| with tf.Session() as sess2: |
| # 変数の読み込み |
| #新しいデータ |
| raw_input2 = numpy.loadtxt(open(" |
| raw_input2 = numpy.loadtxt(open("new_data.csv"), delimiter=",") |
| [tensor, score] = numpy.hsplit(raw_input2, [1]) |
| #モデルつくり |
| feed_dict_test2={ |
| tensor_placeholder: tensor, |
| score_placeholder: score, |
| loss_label_placeholder: "loss_test" |
| } |
| #復元して、学習して得られた損失関数の値を使って、新しく読み込んだ値から予想値を計算するようにoutput関数にくぐらせる |
| saver = tf.train.Saver() |
| cwd = os.getcwd() |
| saver.restore(sess2,cwd + "/model.ckpt") |
| best_match2 = sess2.run(output, feed_dict=feed_dict_test2) |
| prediction = tf.argmax(new_data,None) |
| print(best_match2) |
| print("fin") |
| resess.close() |
| ```` |
