Gain insights into advanced deep learning and NLP by building 12 real-world projects using tools like TensorFlow and scikit-learn. Enhance your portfolio with industry-relevant skills.

dockerfile.tar.gz

python3

spa-job

In this course, you'll not only learn advanced deep learning concepts, but you'll also practice building some advanced deep learning and Natural Language Processing (NLP) projects. By the end, you will be able to utilize deep learning algorithms that are used at large in industry.

 

This is a project-based course with 12 projects in total. This will get you used to building real-world applications that are being used in a wide range of industries. You will be exposed to the most common tools used for machine learning projects including: NumPy, Matplotlib, scikit-learn, Tensorflow, and more.

 

It’s recommended that you have a firm grasp in these topic areas: Python basics, Numpy and Pandas, and Artificial Neural Networks.

 

Once you’re finished, you will have the experience to start building your own amazing projects, and some great new additions to your portfolio.

Building Advanced Deep Learning and NLP Projects

In the previous lesson, we discussed a lot of topics. Now we will be moving ahead and building our model architecture.

# Model architecture
We will define a function that will accept four parameters: the input shape, the output sequence length, the vocabulary size of encrypted text, and the vocabulary size of the plaintext.

def simple_model(input_shape, output_sequence_length, code_vocab_size, plaintext_vocab_size):
    
    learning_rate = 1e-3

    input_seq = Input(input_shape[1:])
    rnn = GRU(64, return_sequences=True)(input_seq)
    logits = TimeDistributed(Dense(plaintext_vocab_size))(rnn)

    model = Model(input_seq, Activation('softmax')(logits))
    model.compile(loss=sparse_categorical_crossentropy,
                  optimizer=Adam(learning_rate),
                  metrics=['accuracy'])
    return model

print("Function Created Successfully!")

**Explanation:**
* We first defined our function, which accepts the four parameters which we discussed above.
* On *line 3*, we defined our learning rate for the network.
* On *line 5*, we created an `Input()` object by specifying the shape of the input data as a parameter.
* On *line 6*, we defined our GRU layer with 64 units. This means that RNN will be unrolled 64 times. Also, the `return_sequences=True` specifies whether to return the last output in the output sequence or not.
* On *line 7*, we defined our `TimeDistributed` layer by passing a dense layer as its parameter.
* We also specified `input_seq` and `rnn` after the function calls. This means that the input to the GRU is `input_seq` and the input to the TimeDistributed layer is `rnn`. This is the Functional API way to create model architectures in Keras.
* On *line 9*, we called the `Model()` which takes two values: what the input is to the model and what the output will be (we also specified the activation that will be applied). We used `softmax` activation because we need the probability values for each output node, and it will select the node with the highest probability.
* On *line 10*, we compiled our model by specifying the loss, optimizer, and metrics that we want to be monitored.

Now, before passing our input to this model, we need to do some reshaping of the input because the model accepts 3-dimensioned input (as we discussed above).

In this lesson, we will be creating the model and training it on our dataset.

Welcome to the Course

Project: Build a COVID-19 Detection System Using X-Rays

Project: Building a Pokemon Classifier Using Transfer Learning

Project: Text Generation Using Markov Chains

Word Embedding: Two Mini Projects

Project: IMDB Reviews Sentiment Analysis

Project: Deciphering Text Using Character-Level RNNs

Project: Emoji Predictor Using Transfer Learning in NLP

Final Exam

Where to Go Next?

Project Creation: Part Three

Model architecture