RNN codes are updated

9.RNN/gp-for-sine-wave.py

@@ -0,0 +1,105 @@
+
+# coding: utf-8
+
+# ## Prediction sine wave function using Gaussian Process
+# 
+# An example for Gaussian process algorithm to predict sine wave function.
+# This example is from ["Gaussian Processes regression: basic introductory example"](http://scikit-learn.org/stable/auto_examples/gaussian_process/plot_gp_regression.html).
+
+import numpy as np
+from sklearn.gaussian_process import GaussianProcess
+from matplotlib import pyplot as pl
+%matplotlib inline
+
+np.random.seed(1)
+
+
+# The function to predict
+def f(x):
+    return x*np.sin(x)
+
+
+# --------------------------
+#  First the noiseless case
+# --------------------------
+
+# Obervations
+X = np.atleast_2d([0., 1., 2., 3., 5., 6., 7., 8., 9.5]).T
+y = f(X).ravel()
+
+#X = np.atleast_2d(np.linspace(0, 100, 200)).T
+
+# Mesh the input space for evaluations of the real function, the prediction and its MSE
+x = np.atleast_2d(np.linspace(0, 10, 1000)).T
+
+# Instanciate a Gaussian Process model
+gp = GaussianProcess(corr='cubic', theta0=1e-2, thetaL=1e-4, thetaU=1e-1,
+                     random_start=100)
+
+# Fit to data using Maximum Likelihood Estimation of the parameters
+gp.fit(X, y)
+
+# Make the prediction on the meshed x-axis (ask for MSE as well)
+y_pred, MSE = gp.predict(x, eval_MSE=True)
+sigma = np.sqrt(MSE)
+
+
+# Plot the function, the prediction and the 95% confidence interval based on the MSE
+fig = pl.figure()
+pl.plot(x, f(x), 'r:', label=u'$f(x) = x\,\sin(x)$')
+pl.plot(X, y, 'r.', markersize=10, label=u'Observations')
+pl.plot(x, y_pred, 'b-', label=u'Prediction')
+pl.fill(np.concatenate([x, x[::-1]]),
+        np.concatenate([y_pred - 1.9600 * sigma,
+                       (y_pred + 1.9600 * sigma)[::-1]]),
+        alpha=.5, fc='b', ec='None', label='95% confidence interval')
+pl.xlabel('$x$')
+pl.ylabel('$f(x)$')
+pl.ylim(-10, 20)
+pl.legend(loc='upper left')
+
+
+# now the noisy case
+X = np.linspace(0.1, 9.9, 20)
+X = np.atleast_2d(X).T
+
+# Observations and noise
+y = f(X).ravel()
+dy = 0.5 + 1.0 * np.random.random(y.shape)
+noise = np.random.normal(0, dy)
+y += noise
+
+# Mesh the input space for evaluations of the real function, the prediction and
+# its MSE
+x = np.atleast_2d(np.linspace(0, 10, 1000)).T
+
+# Instanciate a Gaussian Process model
+gp = GaussianProcess(corr='squared_exponential', theta0=1e-1,
+                     thetaL=1e-3, thetaU=1,
+                     nugget=(dy / y) ** 2,
+                     random_start=100)
+
+# Fit to data using Maximum Likelihood Estimation of the parameters
+gp.fit(X, y)
+
+# Make the prediction on the meshed x-axis (ask for MSE as well)
+y_pred, MSE = gp.predict(x, eval_MSE=True)
+sigma = np.sqrt(MSE)
+
+# Plot the function, the prediction and the 95% confidence interval based on
+# the MSE
+fig = pl.figure()
+pl.plot(x, f(x), 'r:', label=u'$f(x) = x\,\sin(x)$')
+pl.errorbar(X.ravel(), y, dy, fmt='r.', markersize=10, label=u'Observations')
+pl.plot(x, y_pred, 'b-', label=u'Prediction')
+pl.fill(np.concatenate([x, x[::-1]]),
+        np.concatenate([y_pred - 1.9600 * sigma,
+                       (y_pred + 1.9600 * sigma)[::-1]]),
+        alpha=.5, fc='b', ec='None', label='95% confidence interval')
+pl.xlabel('$x$')
+pl.ylabel('$f(x)$')
+pl.ylim(-10, 20)
+pl.legend(loc='upper left')
+
+pl.show()
+

9.RNN/lab-12-1-hello-rnn.py

@@ -0,0 +1,89 @@
+# Lab 12 RNN
+import tensorflow as tf
+import numpy as np
+tf.set_random_seed(777)  # reproducibility
+
+idx2char = ['h', 'i', 'e', 'l', 'o']
+# Teach hello: hihell -> ihello
+x_data = [[0, 1, 0, 2, 3, 3]]   # hihell
+x_one_hot = [[[1, 0, 0, 0, 0],   # h 0
+              [0, 1, 0, 0, 0],   # i 1
+              [1, 0, 0, 0, 0],   # h 0
+              [0, 0, 1, 0, 0],   # e 2
+              [0, 0, 0, 1, 0],   # l 3
+              [0, 0, 0, 1, 0]]]  # l 3
+
+y_data = [[1, 0, 2, 3, 3, 4]]    # ihello
+
+num_classes = 5
+input_dim = 5  # one-hot size
+hidden_size = 5  # output from the LSTM. 5 to directly predict one-hot
+batch_size = 1   # one sentence
+sequence_length = 6  # |ihello| == 6
+
+X = tf.placeholder(
+    tf.float32, [None, sequence_length, hidden_size])  # X one-hot
+Y = tf.placeholder(tf.int32, [None, sequence_length])  # Y label
+
+cell = tf.contrib.rnn.BasicLSTMCell(num_units=hidden_size, state_is_tuple=True)
+initial_state = cell.zero_state(batch_size, tf.float32)
+outputs, _states = tf.nn.dynamic_rnn(
+    cell, X, initial_state=initial_state, dtype=tf.float32)
+
+# FC layer
+X_for_fc = tf.reshape(outputs, [-1, hidden_size])
+# fc_w = tf.get_variable("fc_w", [hidden_size, num_classes])
+# fc_b = tf.get_variable("fc_b", [num_classes])
+# outputs = tf.matmul(X_for_fc, fc_w) + fc_b
+outputs = tf.contrib.layers.fully_connected(
+    inputs=X_for_fc, num_outputs=num_classes, activation_fn=None)
+
+# reshape out for sequence_loss
+outputs = tf.reshape(outputs, [batch_size, sequence_length, num_classes])
+
+weights = tf.ones([batch_size, sequence_length])
+sequence_loss = tf.contrib.seq2seq.sequence_loss(
+    logits=outputs, targets=Y, weights=weights)
+loss = tf.reduce_mean(sequence_loss)
+train = tf.train.AdamOptimizer(learning_rate=0.1).minimize(loss)
+
+prediction = tf.argmax(outputs, axis=2)
+
+with tf.Session() as sess:
+    sess.run(tf.global_variables_initializer())
+    for i in range(50):
+        l, _ = sess.run([loss, train], feed_dict={X: x_one_hot, Y: y_data})
+        result = sess.run(prediction, feed_dict={X: x_one_hot})
+        print(i, "loss:", l, "prediction: ", result, "true Y: ", y_data)
+
+        # print char using dic
+        result_str = [idx2char[c] for c in np.squeeze(result)]
+        print("\tPrediction str: ", ''.join(result_str))
+
+'''
+0 loss: 1.71584 prediction:  [[2 2 2 3 3 2]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  eeelle
+1 loss: 1.56447 prediction:  [[3 3 3 3 3 3]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  llllll
+2 loss: 1.46284 prediction:  [[3 3 3 3 3 3]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  llllll
+3 loss: 1.38073 prediction:  [[3 3 3 3 3 3]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  llllll
+4 loss: 1.30603 prediction:  [[3 3 3 3 3 3]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  llllll
+5 loss: 1.21498 prediction:  [[3 3 3 3 3 3]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  llllll
+6 loss: 1.1029 prediction:  [[3 0 3 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  lhlllo
+7 loss: 0.982386 prediction:  [[1 0 3 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  ihlllo
+8 loss: 0.871259 prediction:  [[1 0 3 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  ihlllo
+9 loss: 0.774338 prediction:  [[1 0 2 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  ihello
+10 loss: 0.676005 prediction:  [[1 0 2 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]]
+	Prediction str:  ihello
+
+...
+
+'''

9.RNN/lab-12-2-char-seq-rnn.py

@@ -0,0 +1,75 @@
+# Lab 12 Character Sequence RNN
+import tensorflow as tf
+import numpy as np
+tf.set_random_seed(777)  # reproducibility
+
+sample = " if you want you"
+idx2char = list(set(sample))  # index -> char
+char2idx = {c: i for i, c in enumerate(idx2char)}  # char -> idex
+
+# hyper parameters
+dic_size = len(char2idx)  # RNN input size (one hot size)
+hidden_size = len(char2idx)  # RNN output size
+num_classes = len(char2idx)  # final output size (RNN or softmax, etc.)
+batch_size = 1  # one sample data, one batch
+sequence_length = len(sample) - 1  # number of lstm rollings (unit #)
+
+sample_idx = [char2idx[c] for c in sample]  # char to index
+x_data = [sample_idx[:-1]]  # X data sample (0 ~ n-1) hello: hell
+y_data = [sample_idx[1:]]   # Y label sample (1 ~ n) hello: ello
+
+X = tf.placeholder(tf.int32, [None, sequence_length])  # X data
+Y = tf.placeholder(tf.int32, [None, sequence_length])  # Y label
+
+x_one_hot = tf.one_hot(X, num_classes)  # one hot: 1 -> 0 1 0 0 0 0 0 0 0 0
+cell = tf.contrib.rnn.BasicLSTMCell(
+    num_units=hidden_size, state_is_tuple=True)
+initial_state = cell.zero_state(batch_size, tf.float32)
+outputs, _states = tf.nn.dynamic_rnn(
+    cell, x_one_hot, initial_state=initial_state, dtype=tf.float32)
+
+# FC layer
+X_for_fc = tf.reshape(outputs, [-1, hidden_size])
+outputs = tf.contrib.layers.fully_connected(outputs, num_classes, activation_fn=None)
+
+# reshape out for sequence_loss
+outputs = tf.reshape(outputs, [batch_size, sequence_length, num_classes])
+
+weights = tf.ones([batch_size, sequence_length])
+sequence_loss = tf.contrib.seq2seq.sequence_loss(
+    logits=outputs, targets=Y, weights=weights)
+loss = tf.reduce_mean(sequence_loss)
+train = tf.train.AdamOptimizer(learning_rate=0.1).minimize(loss)
+
+prediction = tf.argmax(outputs, axis=2)
+
+with tf.Session() as sess:
+    sess.run(tf.global_variables_initializer())
+    for i in range(50):
+        l, _ = sess.run([loss, train], feed_dict={X: x_data, Y: y_data})
+        result = sess.run(prediction, feed_dict={X: x_data})
+
+        # print char using dic
+        result_str = [idx2char[c] for c in np.squeeze(result)]
+
+        print(i, "loss:", l, "Prediction:", ''.join(result_str))
+
+
+'''
+0 loss: 2.35377 Prediction: uuuuuuuuuuuuuuu
+1 loss: 2.21383 Prediction: yy you y    you
+2 loss: 2.04317 Prediction: yy yoo       ou
+3 loss: 1.85869 Prediction: yy  ou      uou
+4 loss: 1.65096 Prediction: yy you  a   you
+5 loss: 1.40243 Prediction: yy you yan  you
+6 loss: 1.12986 Prediction: yy you wann you
+7 loss: 0.907699 Prediction: yy you want you
+8 loss: 0.687401 Prediction: yf you want you
+9 loss: 0.508868 Prediction: yf you want you
+10 loss: 0.379423 Prediction: yf you want you
+11 loss: 0.282956 Prediction: if you want you
+12 loss: 0.208561 Prediction: if you want you
+
+...
+
+'''

9.RNN/lab-12-3-char-seq-softmax-only.py

@@ -0,0 +1,65 @@
+# Lab 12 Character Sequence Softmax only
+import tensorflow as tf
+import numpy as np
+tf.set_random_seed(777)  # reproducibility
+
+sample = " if you want you"
+idx2char = list(set(sample))  # index -> char
+char2idx = {c: i for i, c in enumerate(idx2char)}  # char -> idex
+
+# hyper parameters
+dic_size = len(char2idx)  # RNN input size (one hot size)
+rnn_hidden_size = len(char2idx)  # RNN output size
+num_classes = len(char2idx)  # final output size (RNN or softmax, etc.)
+batch_size = 1  # one sample data, one batch
+sequence_length = len(sample) - 1  # number of lstm rollings (unit #)
+
+sample_idx = [char2idx[c] for c in sample]  # char to index
+x_data = [sample_idx[:-1]]  # X data sample (0 ~ n-1) hello: hell
+y_data = [sample_idx[1:]]   # Y label sample (1 ~ n) hello: ello
+
+X = tf.placeholder(tf.int32, [None, sequence_length])  # X data
+Y = tf.placeholder(tf.int32, [None, sequence_length])  # Y label
+
+# flatten the data (ignore batches for now). No effect if the batch size is 1
+X_one_hot = tf.one_hot(X, num_classes)  # one hot: 1 -> 0 1 0 0 0 0 0 0 0 0
+X_for_softmax = tf.reshape(X_one_hot, [-1, rnn_hidden_size])
+
+# softmax layer (rnn_hidden_size -> num_classes)
+softmax_w = tf.get_variable("softmax_w", [rnn_hidden_size, num_classes])
+softmax_b = tf.get_variable("softmax_b", [num_classes])
+outputs = tf.matmul(X_for_softmax, softmax_w) + softmax_b
+
+# expend the data (revive the batches)
+outputs = tf.reshape(outputs, [batch_size, sequence_length, num_classes])
+weights = tf.ones([batch_size, sequence_length])
+
+# Compute sequence cost/loss
+sequence_loss = tf.contrib.seq2seq.sequence_loss(
+    logits=outputs, targets=Y, weights=weights)
+loss = tf.reduce_mean(sequence_loss)  # mean all sequence loss
+train = tf.train.AdamOptimizer(learning_rate=0.1).minimize(loss)
+
+prediction = tf.argmax(outputs, axis=2)
+
+with tf.Session() as sess:
+    sess.run(tf.global_variables_initializer())
+    for i in range(3000):
+        l, _ = sess.run([loss, train], feed_dict={X: x_data, Y: y_data})
+        result = sess.run(prediction, feed_dict={X: x_data})
+
+        # print char using dic
+        result_str = [idx2char[c] for c in np.squeeze(result)]
+        print(i, "loss:", l, "Prediction:", ''.join(result_str))
+
+'''
+0 loss: 2.29513 Prediction: yu yny y y oyny
+1 loss: 2.10156 Prediction: yu ynu y y oynu
+2 loss: 1.92344 Prediction: yu you y u  you
+
+..
+
+2997 loss: 0.277323 Prediction: yf you yant you
+2998 loss: 0.277323 Prediction: yf you yant you
+2999 loss: 0.277323 Prediction: yf you yant you
+'''