code: 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
  
  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=rnn_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)
  
  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.GradientDescentOptimizer(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.29895 Prediction: nnuffuunnuuuyuy
  1 loss: 2.29675 Prediction: nnuffuunnuuuyuy
  2 loss: 2.29459 Prediction: nnuffuunnuuuyuy
  3 loss: 2.29247 Prediction: nnuffuunnuuuyuy
  
  ...
  
  1413 loss: 1.3745 Prediction: if you want you
  1414 loss: 1.3743 Prediction: if you want you
  1415 loss: 1.3741 Prediction: if you want you
  1416 loss: 1.3739 Prediction: if you want you
  1417 loss: 1.3737 Prediction: if you want you
  1418 loss: 1.37351 Prediction: if you want you
  1419 loss: 1.37331 Prediction: if you want you
  '''
   # Lab 5 Logistic Regression Classifier
  import tensorflow as tf
  tf.set_random_seed(777)  # for reproducibility
  
  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')
  
  # Hypothesis using sigmoid: tf.div(1., 1. + tf.exp(tf.matmul(X, W)))
  hypothesis = tf.sigmoid(tf.matmul(X, W) + b)
  
  # Cost 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)
  
  # 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())
      feed = {X: x_data, Y: y_data}
  
      for step in range(10001):
          sess.run(train, feed_dict=feed)
          if step % 200 == 0:
              print(step, sess.run(cost, feed_dict=feed), sess.run(W))
  
      # Accuracy report
      h, c, a = sess.run([hypothesis, predicted, accuracy], feed_dict=feed)
      print("\nHypothesis: ", h, "\nCorrect (Y): ", c, "\nAccuracy: ", a)
  
  '''
  Hypothesis:  [[ 0.03074029]
   [ 0.15884677]
   [ 0.30486736]
   [ 0.78138196]
   [ 0.93957496]
   [ 0.98016882]]
  Correct (Y):  [[ 0.]
   [ 0.]
   [ 0.]
   [ 1.]
   [ 1.]
   [ 1.]]
  Accuracy:  1.0
  '''
  
apis: tensorflow.placeholder tensorflow.contrib.rnn.BasicLSTMCell numpy.squeeze tensorflow.global_variables_initializer tensorflow.ones tensorflow.reduce_mean tensorflow.nn.dynamic_rnn tensorflow.contrib.seq2seq.sequence_loss tensorflow.set_random_seed tensorflow.one_hot tensorflow.argmax tensorflow.Session tensorflow.train.GradientDescentOptimizer
apis: tensorflow.placeholder tensorflow.equal tensorflow.global_variables_initializer tensorflow.matmul tensorflow.cast tensorflow.set_random_seed tensorflow.train.GradientDescentOptimizer tensorflow.Session tensorflow.log tensorflow.random_normal