commit all files in the local storage

Example#1-10.py

@@ -0,0 +1,50 @@
+import tensorflow as tf
+import numpy as np
+
+xy=np.loadtxt('data-04-zoo.csv', delimiter=',', dtype=np.float32)
+x_data = xy[:, 0:-1]
+y_data = xy[:, [-1]]
+
+nb_classes = 7 # 0~6
+
+X= tf.placeholder(tf.float32, [None, 16])
+Y = tf.placeholder(tf.int32, [None, 1]) # 0~6, shape(?, 1)
+
+Y_one_hot = tf.one_hot(Y, nb_classes) # one hot shape=(?, 1, 7)
+Y_one_hot = tf.reshape(Y_one_hot, [-1, nb_classes]) # shape=(?, 7)
+
+W = tf.Variable(tf.random_normal([16, nb_classes]), name='weight')
+b = tf.Variable(tf.random_normal([nb_classes]), name='bias')
+
+# tf.nn.softmax computes softmax activations
+# softmax = exp(Logists) / reduce_sum(exp(Logists), dim)
+logits = tf.matmul(X, W) + b
+hypothesis = tf.nn.softmax(logits)
+
+# Cross entropy cost/loss
+# cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))
+
+cost_i = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y_one_hot)
+cost = tf.reduce_mean(cost_i)
+optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
+
+prediction = tf.argmax(hypothesis, 1)
+correct_prediction = tf.equal(prediction, tf.arg_max(Y_one_hot, 1))
+accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+
+# Launch graph
+with tf.Session() as sess:
+    sess.run(tf.global_variables_initializer())
+
+    for step in range(2000):
+        sess.run(optimizer, feed_dict={X: x_data, Y: y_data})
+        if step % 100 == 0:
+            loss, acc = sess.run([cost, accuracy], feed_dict={X:x_data, Y: y_data})
+
+            print("Step: {:5}\tLoss: {:.3f}\tAcc: {:.2%}".format(step, loss, acc))
+
+            # Let's see if we can predict
+            pred = sess.run(prediction, feed_dict={X: x_data})
+            # y_data: (N, 1) = flatten => (N, ) matches pred.shape
+            for p, y in zip(pred, y_data.flatten()):
+                print("[{}] Prediction: {} True Y: {}".format(p == int(y), p, int(y)))

Example#1-11.py

@@ -0,0 +1,2 @@
+import tensorflow as tf
+impoty

Example#1-12.py

@@ -0,0 +1,37 @@
+import tensorflow as tf
+import numpy as np
+
+x_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=np.float32)
+y_data = np.array([[0], [1], [1], [0]], dtype=np.float32)
+X = tf.placeholder(tf.float32)
+Y = tf.placeholder(tf.float32)
+
+W1 = tf.Variable(tf.random_normal([2, 2]), name='weight1')
+b1 = tf.Variable(tf.random_normal([2]), name='bias1')
+layer1 = tf.sigmoid(tf.matmul(X, W1) + b1)
+
+W2 = tf.Variable(tf.random_normal([2, 1]), name='weight2')
+b2 = tf.Variable(tf.random_normal([1]), name='bias2')
+hypothesis = tf.sigmoid(tf.matmul(layer1, W2) + b2)
+
+# cost/Loss function
+cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
+train = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
+
+# Accuracy computation
+# True if hypothesis > 0.5 else False
+predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32)
+accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))
+
+# Launch graph
+with tf.Session() as sess:
+    # Initialize TensorFlow variables
+    sess.run(tf.global_variables_initializer())
+    for step in range(10001):
+        sess.run(train, feed_dict={X: x_data, Y: y_data})
+        if step % 100 == 0:
+            print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run([W1, W2]))
+
+    # Accuracy report
+    h, c, a = sess.run([hypothesis, predicted, accuracy], feed_dict={X: x_data, Y: y_data})
+    print("\nhypothesis: ", h, "\nCorrect: ", c, "\nAccuracy: ", a)

Example#1-13.py

@@ -0,0 +1,45 @@
+import tensorflow as tf
+import numpy as np
+
+x_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=np.float32)
+y_data = np.array([[0], [1], [1], [0]], dtype=np.float32)
+X = tf.placeholder(tf.float32)
+Y = tf.placeholder(tf.float32)
+
+W1 = tf.Variable(tf.random_normal([2, 10]), name='weight1')
+b1 = tf.Variable(tf.random_normal([10]), name='bias1')
+layer1 = tf.sigmoid(tf.matmul(X, W1)+b1)
+
+W2 = tf.Variable(tf.random_normal([10, 10]), name='weight2')
+b2 = tf.Variable(tf.random_normal([10]), name='bias2')
+layer2 = tf.sigmoid(tf.matmul(layer1, W2)+b2)
+
+W3 = tf.Variable(tf.random_normal([10, 10]), name='weight3')
+b3 = tf.Variable(tf.random_normal([10]), name='bias3')
+layer3 = tf.sigmoid(tf.matmul(layer2, W3)+b3)
+
+W4 = tf.Variable(tf.random_normal([10, 1]), name='weight4')
+b4 = tf.Variable(tf.random_normal([1]), name='bias4')
+hypothesis = tf.sigmoid(tf.matmul(layer3, W4)+b4)
+
+# cost/Loss function
+cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
+train = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
+
+# Accuracy computation
+# True if hypothesis > 0.5 else False
+predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32)
+accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))
+
+# Launch graph
+with tf.Session() as sess:
+    # Initialize TensorFlow variables
+    sess.run(tf.global_variables_initializer())
+    for step in range(10001):
+        sess.run(train, feed_dict={X: x_data, Y: y_data})
+        if step % 100 == 0:
+            print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run([W1, W2]))
+
+    # Accuracy report
+    h, c, a = sess.run([hypothesis, predicted, accuracy], feed_dict={X: x_data, Y: y_data})
+    print("\nhypothesis: ", h, "\nCorrect: ", c, "\nAccuracy: ", a)

Example#1-14.py

@@ -0,0 +1,68 @@
+# Lab 7 Learning rate and Evaluation
+import tensorflow as tf
+import random
+# import matplotlib.pyplot as plt
+from tensorflow.examples.tutorials.mnist import input_data
+tf.set_random_seed(777)  # reproducibility
+
+mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
+# Check out https://www.tensorflow.org/get_started/mnist/beginners for
+# more information about the mnist dataset
+
+# parameters
+learning_rate = 0.001
+training_epochs = 15
+batch_size = 100
+
+# input place holders
+X = tf.placeholder(tf.float32, [None, 784])
+Y = tf.placeholder(tf.float32, [None, 10])
+
+# weights & bias for nn layers
+W = tf.Variable(tf.random_normal([784, 10]))
+b = tf.Variable(tf.random_normal([10]))
+
+hypothesis = tf.matmul(X, W) + b
+
+# define cost/loss & optimizer
+cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
+    logits=hypothesis, labels=Y
+
+
+))
+optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
+
+# initialize
+sess = tf.Session()
+sess.run(tf.global_variables_initializer())
+
+# train my model
+for epoch in range(training_epochs):
+    avg_cost = 0
+    total_batch = int(mnist.train.num_examples / batch_size)
+
+    for i in range(total_batch):
+        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
+        feed_dict = {X: batch_xs, Y: batch_ys}
+        c, _ = sess.run([cost, optimizer], feed_dict=feed_dict)
+        avg_cost += c / total_batch
+
+    print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost))
+
+print('Learning Finished!')
+
+# Test model and check accuracy
+correct_prediction = tf.equal(tf.argmax(hypothesis, 1), tf.argmax(Y, 1))
+accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+print('Accuracy:', sess.run(accuracy, feed_dict={
+      X: mnist.test.images, Y: mnist.test.labels}))
+
+# Get one and predict
+r = random.randint(0, mnist.test.num_examples - 1)
+print("Label: ", sess.run(tf.argmax(mnist.test.labels[r:r + 1], 1)))
+print("Prediction: ", sess.run(
+    tf.argmax(hypothesis, 1), feed_dict={X: mnist.test.images[r:r + 1]}))
+
+# plt.imshow(mnist.test.images[r:r + 1].
+#           reshape(28, 28), cmap='Greys', interpolation='nearest')
+# plt.show()

Example#1-2.py

@@ -0,0 +1,30 @@
+import tensorflow as tf
+import matplotlib.pyplot as plt
+
+X = [1, 2, 3]
+Y = [1, 2, 3]
+W = tf.placeholder(tf.float32)
+
+# Our hypothesis for linear model X * W
+hypothesis = X * W
+
+# Cost/loss function
+cost = tf.reduce_mean(tf.square(hypothesis - Y))
+# Launch the graph in a session
+sess = tf.Session()
+
+# Initializes global variables in the graph
+sess.run(tf.global_variables_initializer())
+
+# Variables for plotting cost function
+W_val = []
+cost_val = []
+for i in range(-30, 50):
+    feed_W = i * 0.1
+    curr_cost, curr_W = sess.run([cost, W], feed_dict={W: feed_W})
+    W_val.append(curr_W)
+    cost_val.append(curr_cost)
+
+# Show the cost function
+    plt.plot(W_val, cost_val)
+    plt.show()

Example#1-3.py

@@ -0,0 +1,30 @@
+import tensorflow as tf
+
+x_data = [1, 2, 3]
+y_data = [1, 2, 3]
+
+W = tf.Variable(tf.random_normal([1]), name='weight')
+X = tf.placeholder(tf.float32)
+Y = tf.placeholder(tf.float32)
+
+# Our hypothesis for linear model X * W
+hypothesis = X * W
+
+# Cost/loss function
+cost = tf.reduce_sum(tf.square(hypothesis - Y))
+
+# Minimize: Gradient Descent using derivative: W -= Learning_rate * derivative
+learning_rate = 0.1
+gradient = tf.reduce_mean((W*X-Y)*X)
+descent = W - learning_rate * gradient
+update = W.assign(descent)
+
+# Launch the graph in a session
+sess = tf.Session()
+
+# Initializes global variables in the graph
+sess.run(tf.global_variables_initializer())
+for step in range(21):
+    sess.run(update, feed_dict={X: x_data, Y: y_data})
+    print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run(W))
+

Example#1-4.py

@@ -0,0 +1,25 @@
+import tensorflow as tf
+
+X = [1, 2, 3]
+Y = [1, 2, 3]
+
+W = tf.Variable(-3.0)
+# Our hypothesis for linear model X * W
+hypothesis = X * W
+
+# Cost/loss function
+cost = tf.reduce_mean(tf.square(hypothesis - Y))
+
+# Minimize: Gradient Descent Magic
+optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1)
+train = optimizer.minimize(cost)
+
+# Launch the graph in a session
+sess = tf.Session()
+
+# Initializes global variables in the graph
+sess.run(tf.global_variables_initializer())
+
+for step in range(100):
+   print(step, sess.run(W))
+   sess.run(train)

Example#1-5.py

@@ -0,0 +1,26 @@
+import tensorflow as tf
+
+X = [1, 2, 3]
+Y = [1, 2, 3]
+
+W = tf.Variable(5.)
+# Our hypothesis for linear model X * W
+hypothesis = X * W
+# Manual gradient
+gradient = tf.reduce_mean((W * X - Y) * X) * 2
+# Cost/loss function
+cost = tf.reduce_mean(tf.square(hypothesis - Y))
+optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1)
+
+# Get gradients
+gvs = optimizer.compute_gradients(cost)
+# Apply_gradients
+apply_gradients = optimizer.apply_gradients(gvs)
+
+# Launch the graph in a session
+sess = tf.Session()
+sess.run(tf.global_variables_initializer())
+
+for step in range(100):
+   print(step, sess.run([gradient, W, gvs]))
+   sess.run(apply_gradients)

Example#1-6.py

@@ -0,0 +1,12 @@
+import tensorflow as tf
+x_data = [[73., 80., 75],[93., 88., 93.], [89., 91., 90.], [96., 98., 100.], [73., 66., 70.]]
+y_data = [[152.], [185.], [180.], [196.], [142.]]
+#
+X = tf.placeholder(tf.float32, shape=[None, 3])
+Y = tf.placeholder(tf.floar32, shape=[None, 1])
+
+W = tf.Variable(tf.random_normal([3, 1]), name='weight')
+b = tf.Variable(tf.random_normal([1]), name='bias')
+
+# Hypothesis
+hypothesis = tf.matmul(X, W) + b

Example#1-7.py

@@ -0,0 +1,37 @@
+import tensorflow as tf
+
+x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]]
+y_data = [[0], [0], [0], [1], [1], [1]]
+
+# placeholders for a tensor that will be always fed
+X = tf.placeholder(tf.float32, shape=[None, 2])
+Y = tf.placeholder(tf.float32, shape=[None, 1])
+W = tf.Variable(tf.random_normal([2,1]), name='weight')
+b = tf.Variable(tf.random_normal([1]), name='bias')
+
+# Hypotheses using sigmoid: tf.div(1., 1. + tf.exp(tf.matmul(X,W)+b))
+hypothesis = tf.sigmoid(tf.matmul(X, W) + b)
+
+# cost/Loss function
+cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1-Y) * tf.log(1-hypothesis))
+
+train = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(cost)
+
+# Accurate computation
+# True if hypothesis>0.5 else False
+predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32)
+accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))
+
+# Launch graph
+with tf.Session() as sess:
+    # Initialize TensorFlow variables
+    sess.run(tf.global_variables_initializer())
+
+    for step in range(10001):
+        cost_val, _ = sess.run([cost, train], feed_dict={X: x_data, Y: y_data})
+        if step % 200 == 0:
+            print(step, cost_val)
+
+    # Accuracy report
+    h, c, a = sess.run([hypothesis, predicted, accuracy], feed_dict={X: x_data, Y: y_data})
+    print("\nHypothesis: ", h, "\nCorrect (Y): ", c, "\nAccuracy: ", a)