Adding more resources

Author: swaathi

.DS_Store

@@ -0,0 +1,33 @@
+from __future__ import print_function
+
+import tensorflow as tf
+
+x_data = [1, 2, 3]
+y_data = [2, 4, 6]
+
+W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
+b = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
+
+X = tf.placeholder(tf.float32)
+Y = tf.placeholder(tf.float32)
+
+hypothesis = W * X + b
+
+cost = tf.reduce_mean(tf.square(hypothesis - Y))
+
+a = tf.Variable(0.1)
+optimizer = tf.train.GradientDescentOptimizer(a)
+train = optimizer.minimize(cost)
+
+init = tf.global_variables_initializer()
+
+sess = tf.Session()
+sess.run(init)
+
+for step in range(2001):
+    sess.run(train, feed_dict={X: x_data, Y: y_data})
+    if step % 20 == 0:
+        print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run(W), sess.run(b))
+
+print(sess.run(hypothesis, feed_dict={X: 5}))
+print(sess.run(hypothesis, feed_dict={X: 2.5}))

02_tf_basics.py

@@ -0,0 +1,53 @@
+from __future__ import print_function
+
+import os
+import numpy as np
+import tensorflow as tf
+
+from matplotlib import pyplot as plt
+
+filepath = os.path.abspath(__file__)
+PWDPATH = os.path.dirname(filepath)
+DATAPATH = PWDPATH + '/logistic_train.txt'
+
+xy = np.loadtxt(DATAPATH, unpack=True, dtype='float32')
+x_data = xy[0:-1]
+y_data = xy[-1]
+
+X = tf.placeholder(tf.float32)
+Y = tf.placeholder(tf.float32)
+
+W = tf.Variable(tf.random_uniform([1, len(x_data)], -1.0, 1.0))
+
+h = tf.matmul(W, X)
+hypothesis = tf.div(1., 1. + tf.exp(-h))
+
+cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
+
+learning_rate = 0.1
+optimizer = tf.train.GradientDescentOptimizer(learning_rate)
+train = optimizer.minimize(cost)
+
+init = tf.global_variables_initializer()
+
+W_val = []
+cost_val = []
+
+sess = tf.Session()
+sess.run(init)
+
+for step in range(2001):
+    sess.run(train, feed_dict={X: x_data, Y: y_data})
+
+    W_val.append(sess.run(W)[0])
+    cost_val.append(sess.run(cost, feed_dict={X: x_data, Y: y_data}))
+
+    if step % 20 == 0:
+        print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run(W)[0])
+
+fig, (ax) = plt.subplots(1, 1)
+ax.set_ylim(0, 10)
+ax.plot(W_val, cost_val)
+plt.ylabel(sess.run(W))
+plt.xlabel('W')
+plt.show()

03_tf_network.py renamed to basic_tf_network.py

@@ -0,0 +1,7 @@
+#x0 x1 x2 y
+ 1  2  1  0
+ 1  3  2  0
+ 1  3  4  0
+ 1  5  5  1
+ 1  7  5  1
+ 1  2  5  1

04_tf_with_hidden.py renamed to basic_tf_with_hidden_network.py

@@ -0,0 +1,80 @@
+from pybrain.datasets            import ClassificationDataSet
+from pybrain.utilities           import percentError
+from pybrain.tools.shortcuts     import buildNetwork
+from pybrain.supervised.trainers import BackpropTrainer
+from pybrain.structure.modules   import SoftmaxLayer
+
+from scipy import diag
+from numpy.random import multivariate_normal
+
+# What is Multivariate normal distribution?
+
+# In probability theory and statistics, the multivariate normal distribution
+# or multivariate Gaussian distribution, is a generalization of the one-dimensional
+# (univariate) normal distribution to higher dimensions.
+
+# The multivariate normal distribution is often used to describe,
+# at least approximately, any set of (possibly) correlated real-valued random
+# variables each of which clusters around a mean value.
+
+# https://en.wikipedia.org/wiki/Multivariate_normal_distribution
+
+# METHOD: Classification
+# Classify any random point to one of three different classes.
+alldata = ClassificationDataSet(2, 1, nb_classes=3)
+
+# DATASET: Multivariate Gaussian Distribution
+# Produce a set of points in 2D belonging to three different classes.
+
+# Assumed means of three different classes
+means = [(-1,0), (2,4), (3,1)]
+# Assumed covariance of three different classes
+cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])]
+
+# Gather a dataset of 400 values, where each value randomly belongs to one class
+for n in xrange(400):
+    for klass in range(3):
+        input = multivariate_normal(means[klass], cov[klass])
+        alldata.addSample(input, [klass])
+
+# Randomly split the dataset into 75% training and 25% test data sets.
+tstdata, trndata = alldata.splitWithProportion( 0.25 )
+
+# For neural network classification, it is highly advisable to encode classes
+# with one output neuron per class.
+# Note that this operation duplicates the original targets and stores
+# them in an (integer) field named ‘class’.
+trndata._convertToOneOfMany( )
+tstdata._convertToOneOfMany( )
+
+# Explore trndata and tstdata
+print "Number of training patterns: ", len(trndata)
+print "Input and output dimensions: ", trndata.indim, trndata.outdim
+print "First sample (input, target, class):"
+print trndata['input'][0], trndata['target'][0], trndata['class'][0]
+
+# Now build a feed-forward network with 5 hidden units.
+# The input and output layer size must match the dataset’s input and target dimension.
+# You could add additional hidden layers by inserting more numbers giving the desired layer sizes.
+fnn = buildNetwork(trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer)
+
+# Set up a trainer that basically takes the network and training dataset as input.
+# We are using a BackpropTrainer for this.
+trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01)
+
+# Start the training iterations.
+for i in range(20):
+    trainer.trainEpochs(5)
+
+# Evaluate the network on the training and test data.
+trnresult = percentError( trainer.testOnClassData(),
+                        trndata['class'] )
+tstresult = percentError( trainer.testOnClassData(dataset=tstdata),
+                        tstdata['class'] )
+
+print "epoch: %4d" % trainer.totalepochs, \
+      "train error: %5.2f%%" % trnresult, \
+      "test error: %5.2f%%" % tstresult
+
+# To classify new data, just use the activate method
+# self.fnn.classify(data)

linear_regression.py

@@ -0,0 +1,38 @@
+from __future__ import print_function
+
+import os
+
+import numpy as np
+import tensorflow as tf
+
+filepath = os.path.abspath(__file__)
+PWDPATH = os.path.dirname(filepath)
+DATAPATH = PWDPATH + '/softmax_train.txt'
+
+xy = np.loadtxt(DATAPATH, unpack=True, dtype='float32')
+x_data = np.transpose(xy[0:3])
+y_data = np.transpose(xy[3:])
+
+
+X = tf.placeholder("float", [None, 3])
+Y = tf.placeholder("float", [None, 3])
+
+W = tf.Variable(tf.zeros([3, 3]))
+
+# matrix shape X=[8, 3], W=[3, 3]
+hypothesis = tf.nn.softmax(tf.matmul(X, W))
+
+learning_rate = 0.001
+
+cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), reduction_indices=1))
+optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
+
+init = tf.global_variables_initializer()
+
+with tf.Session() as sess:
+    sess.run(init)
+
+    for step in range(2001):
+        sess.run(optimizer, feed_dict={X: x_data, Y: y_data})
+        if step % 200 == 0:
+            print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run(W))

logistic_regression.py

@@ -0,0 +1,9 @@
+# x0 x1 x2 y[A  B  C]
+  1  2  1    0  0  1
+  1  3  2    0  0  1
+  1  3  4    0  0  1
+  1  5  5    0  1  0
+  1  7  5    0  1  0
+  1  2  5    0  1  0
+  1  6  6    1  0  0
+  1  7  7    1  0  0

logistic_train.txt

@@ -0,0 +1,25 @@
+from __future__ import print_function
+
+import tensorflow as tf
+
+# Start tf session
+sess = tf.Session()
+
+a = tf.constant(2)
+b = tf.constant(3)
+
+c = a+b
+
+# Print out operation everything is operation
+print(a)
+print(b)
+print(c)
+
+print(a+b)
+
+
+# Print out the result of operation
+print(sess.run(a))
+print(sess.run(b))
+print(sess.run(c))
+print(sess.run(a+b))

multivariate_gaussian_distribution_classification.py

@@ -32,5 +32,4 @@
 
     weight = weight + (learning_rate * gradient)
 
-    print 'Weight: ', weight
-    print ''
+    print 'Weight: ', weight, '\n'

softmax_classification.py

@@ -0,0 +1,11 @@
+from __future__ import print_function
+
+
+import tensorflow as tf
+
+hello = tf.constant('Hello, TensorFlow!')
+
+# Start tf session
+sess = tf.Session()
+
+print(sess.run(hello))

softmax_train.txt

@@ -0,0 +1,24 @@
+from __future__ import print_function
+
+
+import tensorflow as tf
+
+a = tf.placeholder(tf.int16)
+b = tf.placeholder(tf.int16)
+
+add = tf.add(a, b)
+mul = tf.multiply(a, b)
+
+# Same op?
+print(add)
+print(a + b)
+print(mul)
+print(a * b)
+
+# Launch the default graph
+with tf.Session() as sess:
+    print(sess.run(add, feed_dict={a: 2, b: 3}))
+
+    # it's work!
+    feed = {a: 3, b: 5}
+    print(sess.run(mul, feed_dict=feed))

tf_basics/basic_operations.py

@@ -0,0 +1,33 @@
+from __future__ import print_function
+
+
+import tensorflow as tf
+
+x_data = [1, 2, 3]
+y_data = [2, 4, 6]
+
+W = tf.Variable(tf.random_uniform([1], -10.0, 10.0))
+
+X = tf.placeholder(tf.float32)
+Y = tf.placeholder(tf.float32)
+
+hypothesis = W * X
+
+cost = tf.reduce_mean(tf.square(hypothesis - Y))
+
+lr = 0.1
+descent = W - tf.multiply(lr, tf.reduce_mean(tf.multiply((tf.multiply(W, X) - Y), X)))
+train = W.assign(descent)
+
+init = tf.global_variables_initializer()
+
+sess = tf.Session()
+sess.run(init)
+
+for step in range(2001):
+    sess.run(train, feed_dict={X: x_data, Y: y_data})
+    if step % 20 == 0:
+        print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run(W))
+
+print(sess.run(hypothesis, feed_dict={X: 5}))
+print(sess.run(hypothesis, feed_dict={X: 2.5}))

01_basics.py renamed to tf_basics/gradient_loss_and_weight.py

@@ -0,0 +1,42 @@
+from __future__ import print_function
+
+import tensorflow as tf
+from matplotlib import pyplot as plt
+
+# Graph Input
+X = [1., 2., 3.]
+Y = [2., 4., 6.]
+n_samples = len(X)
+
+# model weight
+W = tf.placeholder(tf.float32)
+
+# Construct a linear model
+hypothesis = tf.multiply(X, W)
+
+# Cost function
+# for each y,
+# c = sum(y' - y)^2
+# take mean value
+# c / n_samples
+cost = tf.reduce_sum(tf.pow(hypothesis - Y, 2)) / n_samples
+
+init = tf.global_variables_initializer()
+
+# for graphs
+W_val = []
+cost_val = []
+
+# Launch the graphs
+sess = tf.Session()
+sess.run(init)
+
+for i in range(-30, 50):
+    print(i * -0.1, sess.run(cost, feed_dict={W: i * 0.1}))
+    W_val.append(i * 0.1)
+    cost_val.append(sess.run(cost, feed_dict={W: i * 0.1}))
+
+plt.plot(W_val, cost_val, 'ro')
+plt.ylabel('cost')
+plt.xlabel('W')
+plt.show()