student version l1p2

Author: avaamini

lab1/TF_Part2_Music_Generation.ipynb

@@ -10,9 +10,9 @@
         "  <td align=\"center\"><a target=\"_blank\" href=\"http://introtodeeplearning.com\">\n",
         "        <img src=\"https://i.ibb.co/Jr88sn2/mit.png\" style=\"padding-bottom:5px;\" />\n",
         "      Visit MIT Deep Learning</a></td>\n",
-        "  <td align=\"center\"><a target=\"_blank\" href=\"https://colab.research.google.com/github/aamini/introtodeeplearning/blob/master/lab1/solutions/TF_Part2_Music_Generation_Solution.ipynb\">\n",
+        "  <td align=\"center\"><a target=\"_blank\" href=\"https://colab.research.google.com/github/aamini/introtodeeplearning/blob/master/lab1/TF_Part2_Music_Generation.ipynb\">\n",
         "        <img src=\"https://i.ibb.co/2P3SLwK/colab.png\"  style=\"padding-bottom:5px;\" />Run in Google Colab</a></td>\n",
-        "  <td align=\"center\"><a target=\"_blank\" href=\"https://github.com/aamini/introtodeeplearning/blob/master/lab1/solutions/TF_Part2_Music_Generation_Solution.ipynb\">\n",
+        "  <td align=\"center\"><a target=\"_blank\" href=\"https://github.com/aamini/introtodeeplearning/blob/master/lab1/TF_Part2_Music_Generation.ipynb\">\n",
         "        <img src=\"https://i.ibb.co/xfJbPmL/github.png\"  height=\"70px\" style=\"padding-bottom:5px;\"  />View Source on GitHub</a></td>\n",
         "</table>\n",
         "\n",
@@ -266,11 +266,7 @@
         "  the number of characters in the input string\n",
         "'''\n",
         "def vectorize_string(string):\n",
-        "  vectorized_output = np.array([char2idx[char] for char in string])\n",
-        "  return vectorized_output\n",
-        "\n",
-        "# def vectorize_string(string):\n",
-        "  # TODO\n",
+        "  '''TODO'''\n",
         "\n",
         "vectorized_songs = vectorize_string(songs_joined)"
       ]
@@ -329,11 +325,10 @@
         "  idx = np.random.choice(n-seq_length, batch_size)\n",
         "\n",
         "  '''TODO: construct a list of input sequences for the training batch'''\n",
-        "  input_batch = [vectorized_songs[i : i+seq_length] for i in idx]\n",
-        "  # input_batch = # TODO\n",
+        "  input_batch = # TODO\n",
+        "\n",
         "  '''TODO: construct a list of output sequences for the training batch'''\n",
-        "  output_batch = [vectorized_songs[i+1 : i+seq_length+1] for i in idx]\n",
-        "  # output_batch = # TODO\n",
+        "  output_batch = # TODO\n",
         "\n",
         "  # x_batch, y_batch provide the true inputs and targets for network training\n",
         "  x_batch = np.reshape(input_batch, [batch_size, seq_length])\n",
@@ -464,14 +459,12 @@
         "\n",
         "    # Layer 2: LSTM with `rnn_units` number of units.\n",
         "    # TODO: Call the LSTM function defined above to add this layer.\n",
-        "    LSTM(rnn_units),\n",
-        "    # LSTM('''TODO'''),\n",
+        "    LSTM('''TODO'''),\n",
         "\n",
         "    # Layer 3: Dense (fully-connected) layer that transforms the LSTM output\n",
         "    #   into the vocabulary size.\n",
         "    # TODO: Add the Dense layer.\n",
-        "    tf.keras.layers.Dense(vocab_size)\n",
-        "    # '''TODO: DENSE LAYER HERE'''\n",
+        "    '''TODO: DENSE LAYER HERE'''\n",
         "  ])\n",
         "\n",
         "  return model\n",
@@ -620,14 +613,12 @@
         "'''TODO: define the loss function to compute and return the loss between\n",
         "    the true labels and predictions (logits). Set the argument from_logits=True.'''\n",
         "def compute_loss(labels, logits):\n",
-        "  loss = tf.keras.losses.sparse_categorical_crossentropy(labels, logits, from_logits=True)\n",
-        "  # loss = tf.keras.losses.sparse_categorical_crossentropy('''TODO''', '''TODO''', from_logits=True) # TODO\n",
+        "  loss = tf.keras.losses.sparse_categorical_crossentropy('''TODO''', '''TODO''', from_logits=True) # TODO\n",
         "  return loss\n",
         "\n",
         "'''TODO: compute the loss using the true next characters from the example batch\n",
         "    and the predictions from the untrained model several cells above'''\n",
-        "example_batch_loss = compute_loss(y, pred)\n",
-        "# example_batch_loss = compute_loss('''TODO''', '''TODO''') # TODO\n",
+        "example_batch_loss = compute_loss('''TODO''', '''TODO''') # TODO\n",
         "\n",
         "print(\"Prediction shape: \", pred.shape, \" # (batch_size, sequence_length, vocab_size)\")\n",
         "print(\"scalar_loss:      \", example_batch_loss.numpy().mean())"
@@ -732,37 +723,32 @@
         "\n",
         "'''TODO: instantiate a new model for training using the `build_model`\n",
         "  function and the hyperparameters created above.'''\n",
-        "model = build_model(vocab_size, params[\"embedding_dim\"], params[\"rnn_units\"], params[\"batch_size\"])\n",
-        "# model = build_model('''TODO: arguments''')\n",
+        "model = build_model('''TODO: arguments''')\n",
         "\n",
         "'''TODO: instantiate an optimizer with its learning rate.\n",
         "  Checkout the tensorflow website for a list of supported optimizers.\n",
         "  https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/\n",
         "  Try using the Adam optimizer to start.'''\n",
-        "optimizer = tf.keras.optimizers.Adam(params[\"learning_rate\"])\n",
-        "# optimizer = # TODO\n",
+        "optimizer = # TODO\n",
         "\n",
         "@tf.function\n",
         "def train_step(x, y):\n",
         "  # Use tf.GradientTape()\n",
         "  with tf.GradientTape() as tape:\n",
         "\n",
         "    '''TODO: feed the current input into the model and generate predictions'''\n",
-        "    y_hat = model(x) # TODO\n",
-        "    # y_hat = model('''TODO''')\n",
+        "    y_hat = model('''TODO''')\n",
         "\n",
         "    '''TODO: compute the loss!'''\n",
-        "    loss = compute_loss(y, y_hat) # TODO\n",
-        "    # loss = compute_loss('''TODO''', '''TODO''')\n",
+        "    loss = compute_loss('''TODO''', '''TODO''')\n",
         "\n",
         "  # Now, compute the gradients\n",
         "  '''TODO: complete the function call for gradient computation.\n",
         "      Remember that we want the gradient of the loss with respect all\n",
         "      of the model parameters.\n",
         "      HINT: use `model.trainable_variables` to get a list of all model\n",
         "      parameters.'''\n",
-        "  grads = tape.gradient(loss, model.trainable_variables) # TODO\n",
-        "  # grads = tape.gradient('''TODO''', '''TODO''')\n",
+        "  grads = tape.gradient('''TODO''', '''TODO''')\n",
         "\n",
         "  # Apply the gradients to the optimizer so it can update the model accordingly\n",
         "  optimizer.apply_gradients(zip(grads, model.trainable_variables))\n",
@@ -836,8 +822,7 @@
       "outputs": [],
       "source": [
         "'''TODO: Rebuild the model using a batch_size=1'''\n",
-        "model = build_model(vocab_size, params[\"embedding_dim\"], params[\"rnn_units\"], batch_size=1) # TODO\n",
-        "# model = build_model('''TODO''', '''TODO''', '''TODO''', batch_size=1)\n",
+        "model = build_model('''TODO''', '''TODO''', '''TODO''', batch_size=1)\n",
         "\n",
         "# Restore the model weights for the last checkpoint after training\n",
         "model.build(tf.TensorShape([1, None]))\n",
@@ -892,8 +877,7 @@
         "  # Evaluation step (generating ABC text using the learned RNN model)\n",
         "\n",
         "  '''TODO: convert the start string to numbers (vectorize)'''\n",
-        "  input_eval = [char2idx[s] for s in start_string] # TODO\n",
-        "  # input_eval = ['''TODO''']\n",
+        "  input_eval = ['''TODO''']\n",
         "  input_eval = tf.expand_dims(input_eval, 0)\n",
         "\n",
         "  # Empty string to store our results\n",
@@ -905,24 +889,21 @@
         "\n",
         "  for i in tqdm(range(generation_length)):\n",
         "      '''TODO: evaluate the inputs and generate the next character predictions'''\n",
-        "      predictions = model(input_eval)\n",
-        "      # predictions = model('''TODO''')\n",
+        "      predictions = model('''TODO''')\n",
         "\n",
         "      # Remove the batch dimension\n",
         "      predictions = tf.squeeze(predictions, 0)\n",
         "\n",
         "      '''TODO: use a multinomial distribution to sample'''\n",
-        "      predicted_id = tf.random.categorical(predictions, num_samples=1)[-1,0].numpy()\n",
-        "      # predicted_id = tf.random.categorical('''TODO''', num_samples=1)[-1,0].numpy()\n",
+        "      predicted_id = tf.random.categorical('''TODO''', num_samples=1)[-1,0].numpy()\n",
         "\n",
         "      # Pass the prediction along with the previous hidden state\n",
         "      #   as the next inputs to the model\n",
         "      input_eval = tf.expand_dims([predicted_id], 0)\n",
         "\n",
         "      '''TODO: add the predicted character to the generated text!'''\n",
         "      # Hint: consider what format the prediction is in vs. the output\n",
-        "      text_generated.append(idx2char[predicted_id]) # TODO\n",
-        "      # text_generated.append('''TODO''')\n",
+        "      text_generated.append('''TODO''')\n",
         "\n",
         "  return (start_string + ''.join(text_generated))"
       ]
@@ -937,8 +918,7 @@
       "source": [
         "'''TODO: Use the model and the function defined above to generate ABC format text of length 1000!\n",
         "    As you may notice, ABC files start with \"X\" - this may be a good start string.'''\n",
-        "generated_text = generate_text(model, start_string=\"X\", generation_length=1000) # TODO\n",
-        "# generated_text = generate_text('''TODO''', start_string=\"X\", generation_length=1000)"
+        "generated_text = generate_text('''TODO''', start_string=\"X\", generation_length=1000)"
       ]
     },
     {