n_a = 64

reshapor = Reshape((1, 78))
(), below
LSTM_cell = LSTM(n_a, return_state = True) densor = Dense(n_values, activation='softmax')

def (Tx, n_a, n_values): """
    Implement the model
    Arguments:
    Tx -- length of the sequence in a corpus
    n_a -- the number of activations used in our model
    n_values -- number of unique values in the music data
    Returns:
    model -- a keras model with the
    """
    # Define the input of your model with a shape
    X = Input(shape=(Tx, n_values))
    # Define s0, initial hidden state for the decoder LSTM
e)
a0 = Input(shape=(n_a,), name='a0')
c0 = Input(shape=(n_a,), name='c0')
a = a0
c = c0
### START CODE HERE ###
# Step 1: Create empty list to append
outputs = []
# Step 2: Loop
for t in range(Tx):
the outputs while you iterate (≈1 lin
    # Step 2.A: select the "t"th time step vector from X.
x = Lambda(lambda x: X[:,t,:])(X)
# Step 2.B: Use reshapor to reshape x to be (1, n_values) (≈1 line) x = reshapor(x)
# Step 2.C: Perform one step of the LSTM_cell
# a, _, c = Model.add(LSTM_cell)
a, _, c = LSTM_cell(x, initial_state=[a, c])
# Step 2.D: Apply densor to the hidden state output of LSTM_Cell out = densor(a)
# Step 2.E: add the output to "outputs"
outputs.append(out)
# Step 3: Create model instance
model = Model([X, a0, c0], outputs)
### END CODE HERE ###
return model

model = djmodel(Tx = 30 , n_a = 64, n_values = 78)

opt = Adam(lr=0.01, beta_1=0.9, beta_2=0.999, decay=0.01)
model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accurac
y'])

m = 60
a0 = np.zeros((m, n_a))
c0 = np.zeros((m, n_a))

model.fit([X, a0, c0], list(Y), epochs=100)

# GRADED FUNCTION: music_inference_model
def music_inference_model(LSTM_cell, densor, n_values = 78, n_a = 64, Ty = 100): """
    Uses the trained "LSTM_cell" and "densor" from model() to generate a sequenc
e of values.
    Arguments:
    LSTM_cell -- the trained "LSTM_cell" from model(), Keras layer object
    densor -- the trained "densor" from model(), Keras layer object
    n_values -- integer, umber of unique values
    n_a -- number of units in the LSTM_cell
    Ty -- integer, number of time steps to generate
    Returns:
    inference_model -- Keras model instance
    """
    # Define the input of your model with a shape
    x0 = Input(shape=(1, n_values))
    # Define s0, initial hidden state for the decoder LSTM
    a0 = Input(shape=(n_a,), name='a0')
    c0 = Input(shape=(n_a,), name='c0')
    a = a0
    c = c0
x = x0
    ### START CODE HERE ###
# Step 1: Create an empty list of "outputs" to later store your predicted va lues (≈1 line)
outputs = []
    # Step 2: Loop over Ty and generate a value at every time step
for t in range(Ty):
# Step 2.A: Perform one step of LSTM_cell (≈1 line)
        a, _, c = LSTM_cell(x, initial_state=[a, c])
# Step 2.B: Apply Dense layer to the hidden state output of the LSTM_cel l (≈1 line)
        out = densor(a)
# Step 2.C: Append the prediction "out" to "outputs". out.shape = (None, 78) (≈1 line)
        outputs.append(out)
        # Step 2.D: Select the next value according to "out", and set "x" to be
 the one-hot representation of the
        #           selected value, which will be passed as the input to LSTM_ce
ll on the next step. We have provided
        #           the line of code you need to do this.
        x = Lambda(one_hot)(out)
# Step 3: Create model instance with the correct "inputs" and "outputs" (≈1 line)
    inference_model = Model([x0, a0, c0], outputs)
### END CODE HERE ###
  return inference_model

inference_model = music_inference_model(LSTM_cell, densor, n_values = 78, n_a =
64, Ty = 50)

x_initializer = np.zeros((1, 1, 78))
a_initializer = np.zeros((1, n_a))
c_initializer = np.zeros((1, n_a))

# GRADED FUNCTION: predict_and_sample
def predict_and_sample(inference_model, x_initializer = x_initializer, a_initial izer = a_initializer,
                       c_initializer = c_initializer):
    """
    Predicts the next value of values using the inference model.
    Arguments:
    inference_model -- Keras model instance for inference time
    x_initializer -- numpy array of shape (1, 1, 78), one-hot vector initializin
g the values generation
    a_initializer -- numpy array of shape (1, n_a), initializing the hidden stat
e of the LSTM_cell
    c_initializer -- numpy array of shape (1, n_a), initializing the cell state
 of the LSTM_cel
Returns:
    results -- numpy-array of shape (Ty, 78), matrix of one-hot vectors represen
ting the values generated
    indices -- numpy-array of shape (Ty, 1), matrix of indices representing the
 values generated
"""
    ### START CODE HERE ###
    # Step 1: Use your inference model to predict an output sequence given x_ini
tializer, a_initializer and c_initializer.
    pred = inference_model.predict([x_initializer, a_initializer, c_initializer
])
    # Step 2: Convert "pred" into an np.array() of indices with the maximum prob
abilities
    indices = np.argmax(pred, axis=2)
    # Step 3: Convert indices to one-hot vectors, the shape of the results shoul
d be (1, )
    results = to_categorical(indices)
    ### END CODE HERE ###
return results, indices

IPython.display.Audio('./data/30s_trained_model.mp3')