Merge pull request #37 from gurumov/master

minor fixes in the examples

Author: chiphuyen

assignments/exercises/e01.py

@@ -17,7 +17,7 @@
 out = tf.cond(tf.greater(x, y), lambda: tf.add(x, y), lambda: tf.subtract(x, y))
 
 ###############################################################################
-# 1b: Create two 0-d tensors x and y randomly selected from -1 and 1.
+# 1b: Create two 0-d tensors x and y randomly selected from the range [-1, 1).
 # Return x + y if x < y, x - y if x > y, 0 otherwise.
 # Hint: Look up tf.case().
 ###############################################################################

assignments/exercises/e01_sol.py

@@ -16,7 +16,7 @@
 out = tf.cond(tf.greater(x, y), lambda: tf.add(x, y), lambda: tf.subtract(x, y))
 
 ###############################################################################
-# 1b: Create two 0-d tensors x and y randomly selected from -1 and 1.
+# 1b: Create two 0-d tensors x and y randomly selected from the range [-1, 1).
 # Return x + y if x < y, x - y if x > y, 0 otherwise.
 # Hint: Look up tf.case().
 ###############################################################################

examples/02_simple_tf.py

@@ -28,7 +28,7 @@
 #	 [4 6]]
 
 tf.zeros(shape, dtype=tf.float32, name=None)
-creates a tensor of shape and all elements will be zeros (when ran in session)
+#creates a tensor of shape and all elements will be zeros (when ran in session)
 
 x = tf.zeros([2, 3], tf.int32) 
 y = tf.zeros_like(x, optimize=True)

examples/03_linear_regression_starter.py

@@ -26,39 +26,35 @@
 
 # Step 2: create placeholders for input X (number of fire) and label Y (number of theft)
 # Both have the type float32
-X = tf.placeholders(tf.float32, name='X')
-Y = tf.placeholders(tf.float32, name='Y')
+
 
 # Step 3: create weight and bias, initialized to 0
 # name your variables w and b
-w = tf.Variable(0.0, 'weights')
-b = tf.Variable(0.0, 'biases')
 
 
 # Step 4: predict Y (number of theft) from the number of fire
 # name your variable Y_predicted
-Y_predicted = tf.matmul(X, w) + b
+
 
 # Step 5: use the square error as the loss function
 # name your variable loss
-loss = (Y - Y_predicted) ** 2
+
 
 # Step 6: using gradient descent with learning rate of 0.01 to minimize loss
-optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(loss)
 
 # Phase 2: Train our model
 with tf.Session() as sess:
 	# Step 7: initialize the necessary variables, in this case, w and b
 	# TO - DO	
-	sess.run(tf.global_variables_initializer())
+
 
 	# Step 8: train the model
 	for i in range(50): # run 100 epochs
 		total_loss = 0
 		for x, y in data:
 			# Session runs optimizer to minimize loss and fetch the value of loss. Name the received value as l
 			# TO DO: write sess.run()
-			_, l = sess.run([optimizer, loss], feed_dict={X: x, Y: y})
+
 			total_loss += l
 		print("Epoch {0}: {1}".format(i, total_loss/n_samples))
 

examples/04_word2vec_no_frills.py

@@ -1,4 +1,4 @@
-""" The mo frills implementation of word2vec skip-gram model using NCE loss. 
+""" The no frills implementation of word2vec skip-gram model using NCE loss.
 Author: Chip Huyen
 Prepared for the class CS 20SI: "TensorFlow for Deep Learning Research"
 cs20si.stanford.edu

examples/04_word2vec_starter.py

@@ -32,68 +32,53 @@ def word2vec(batch_gen):
     # center_words have to be int to work on embedding lookup
 
     # TO DO
-    with tf.name_scope('data'):
-        center_words = tf.placeholder(tf.int32, [BATCH_SIZE], name='center_words')
-        target_words = tf.placeholder(tf.int32, [BATCH_SIZE, 1], name='target_words')
+
 
     # Step 2: define weights. In word2vec, it's actually the weights that we care about
     # vocab size x embed size
     # initialized to random uniform -1 to 1
 
     # TOO DO
-    with tf.name_scope('embedding_matrix'):
-        embed_matrix = tf.Variable(tf.random_uniform([VOCAB_SIZE, EMBED_SIZE], -1.0, 1.0), name='embed_matrix')
+
 
     # Step 3: define the inference
     # get the embed of input words using tf.nn.embedding_lookup
     # embed = tf.nn.embedding_lookup(embed_matrix, center_words, name='embed')
 
     # TO DO
-    with tf.name_scope('loss'):
-        embed = tf.nn.embedding_lookup(embed_matrix, center_words, name='embed')
+
 
         # Step 4: construct variables for NCE loss
         # tf.nn.nce_loss(weights, biases, labels, inputs, num_sampled, num_classes, ...)
         # nce_weight (vocab size x embed size), intialized to truncated_normal stddev=1.0 / (EMBED_SIZE ** 0.5)
         # bias: vocab size, initialized to 0
 
         # TO DO
-        nce_weights = tf.Variable(tf.truncated_normal([VOCAB_SIZE, EMBED_SIZE],
-                                                        stddev=1.0 / (EMBED_SIZE ** 0.5)),
-                                                        name='nce_weights')
-        nce_biases = tf.Variable(tf.zeros(VOCAB_SIZE), name='nce_biases')
+
 
         # define loss function to be NCE loss function
         # tf.nn.nce_loss(weights, biases, labels, inputs, num_sampled, num_classes, ...)
         # need to get the mean accross the batch
         # note: you should use embedding of center words for inputs, not center words themselves
 
         # TO DO
-        nce_loss = tf.nn.nce_loss(weights=nce_weights, 
-                              biases=nce_biases, 
-                              labels=target_words, 
-                              inputs=embed, 
-                              num_sampled=NUM_SAMPLED, 
-                              num_classes=VOCAB_SIZE, 
-                              name='loss')
-        loss = tf.reduce_mean(nce_loss)
+
 
     # Step 5: define optimizer
 
     # TO DO
-    optimizer = tf.GradientDescentOptimizer(LEARNING_RATE).minimize(loss)
-    
+
+
 
     with tf.Session() as sess:
         # TO DO: initialize variables
-        sess.run(tf.global_variable_initializer())
+
 
         total_loss = 0.0 # we use this to calculate the average loss in the last SKIP_STEP steps
         writer = tf.summary.FileWriter('./graphs/no_frills/', sess.graph)
         for index in range(NUM_TRAIN_STEPS):
             centers, targets = next(batch_gen)
             # TO DO: create feed_dict, run optimizer, fetch loss_batch
-            _, loss_batch = sess.run([optimizer, loss], feed_dict={center_words: centers, target_words: targets})
 
             total_loss += loss_batch
             if (index + 1) % SKIP_STEP == 0: