Cover image for Python Deep Learning Projects

Python Deep Learning Projects

Author Matthew Lamons , Rahul Kumar
Release Date: 2018/11/01
ISBN: 9781788997096
Topic:
0%
169
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

Book Description

Insightful practical projects to master deep learning and neural network architectures using Python, Keras and MXNet

About This Book

  • Rich projects on computer vision, NLP, and image processing
  • Build your own neural network and explore innumerable possibilities with deep learning
  • Explore the power of Python for deep learning in various scenarios using insightful projects

Who This Book Is For

This book is for developers, data scientists, or enthusiasts, who have sound knowledge of python programming, basics of machine learning, and want to break into deep learning, either for opening a new career opportunity or for realizing their own AI projects.

What You Will Learn

  • Set up a Deep Learning development environment on AWS, using GPU-powered instances and the Deep Learning AMI
  • Implement Sequence to Sequence Networks for modeling natural language processing
  • Develop an end-to-end speech recognition system
  • Build a system for pixel-wise semantic labeling of an image
  • Develop a system that generates images and their regions

In Detail

Deep Learning has quietly revolutionized every field of Artificial Intelligence, enabling the development of applications that a few years ago were considered almost impossible.

This book will provide all the knowledge needed to implement complex deep learning projects in the field of computational linguistics and computer vision. Each new project will build upon the experience and knowledge accumulated in the previous ones, allowing the reader to progressively master the subject.

You will learn neural network models implementing a text classifier system using Recurrent Neural network model (RNN) and optimize it to understand the shortcomings you might come across while implementing a simple deep learning system. If you are looking to implement intelligent systems like Automatic Machine Translation, Handwriting Generation, Character Text Generation, Object Classification in Photographs, Colorization of Images, Image Caption Generation, Character Text Generation or Automatic Game Playing into your application then this book is for you.

By the end of this book, you will come across various Recurrent and Convolutional Neural network implementations with practical hands-on to modeling concepts like regularization, Gradient clipping, and gradient normalization, LSTM, Bidirectional RNN’s through a series engaging projects.

Style and approach

One stop guide to gain deep learning knowledge and skills by working on authentic, engaging and complex projects with detailed end-to-end implementations.

Downloading the example code for this book. You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the code file.

Table of Contents

  1. 1 - Building Deep Learning Environment
    1. Building a common Deep Learning environment
      1. Get focused and into the code!
    2. Deep Learning environment setup in local
      1. Download and install Anaconda
        1. Installing Deep Learning libraries
    3. Deep Learning environment setup in the cloud
    4. Cloud platforms for deployment 
      1. Prerequisites
      2. Setup the GCP
    5. Automating the setup process
    6. Summary
  2. 2 - Training NN for Prediction using Regression
    1. Introduction
    2. Building a regression model for prediction using a multilayer perceptron - A deep neural network
    3. Exploring MNIST dataset
    4. Intuition and preparation
      1. Defining regression
      2. Defining project structure
    5. Let's code the implementation!
      1. Defining hyperparameters
      2. Model definition
      3. Build the training loop
        1. Overfitting and Underfitting 
      4. Building inference
    6. The conclusion to the project
    7. Summary
  3. 3 - Word representation using Word2VEC
    1. Learning Word Vectors
      1. Load all the dependencies
        1. Prepare the Text Corpus
        2. Defining Our Word2vec Model
        3. Let's Train The Model
        4. Analysing The Model
        5. Plotting The Word Cluster Using The t-SNE Algorithm
    2. Visualizing the Embedding Space - Plotting the model on Tensorboard
    3. Building language model using CNN + word2vec
      1. Exploring The CNN Model
        1. Understanding Data Format
        2.  Integrating word2vec with CNN
        3. Executing the Model 
      2. Deploy the model into production
    4. Summary
  4. 4 - Build NLP pipeline for building chatbots
    1. Basics of NLP pipeline
      1. Tokenisation
      2. Part of speech tagging
        1. Extracting Nouns
        2. Extracting Verbs
      3. Dependency Parsing
      4. Named Entity Recognition
    2. Building conversational bots
      1. What is TF-IDF?
        1. Preparing dataset
        2. Implementation
          1. Creating Vectorizer
          2. Process Query
          3. Rank Results
      2. Advance chatbots using NER
        1. Installing Rasa
        2. Preparing dataset
        3. Train the model
        4. Deploy the model
    3. Serving chatbots
    4. Summary
  5. 5 - Sequence-to-sequence models for building chatbots
    1. Introducing RNNs
      1. RNN Architectures
    2. Implementing basic RNN
      1. Importing all the dependencies
      2. Preparing dataset
      3. Hyperparameter
      4. Defining Basic RNN cell model
      5. Training the RNN Model
      6. Evaluation Of the RNN Model
    3. LSTM Architecture
    4. Implementing LSTM Model
      1. Defining LSTM model
      2. Training the LSTM Model
      3. Evaluation of the LSTM model
    5. Sequence-to-Sequence model
      1. Data Preparation
      2. Defining seq2seq model
      3. Hyperparameters
      4. Training the seq2seq model
      5. Evaluation of the seq2seq model
    6. Summary
  6. 6 Generative Language model for content creation
    1. LSTM For Text Generation
      1. Data pre-processing
      2. Defining The LSTM Model For Text Generation
      3. Training The Model
      4. Inference and Results
    2. Generate Lyrics using Deep (Multi-layer) LSTM
      1. Data pre-processing
      2. Defining the model
      3. Training the Deep Tensorflow based LSTM Model
      4. Inference
      5. Output
    3. Generate Music using Multi-layer LSTM
      1. Pre-processing data
      2. Define model and Train
      3. Generating music
    4. Summary
  7. 14 - Image translation using GANs for style transfer
    1. INTRODUCTION
    2. Let's Code the Implementation!
      1. Importing all the dependencies
      2. Exploring the data
      3. Preparing the data
        1. Type Conversion, Centering and Scaling
        2. Masking / Inserting Noise
        3. Reshaping
        4. MNIST Classifier
      4. Defining Hyperparameters for GAN
      5. Building the GAN Model Components
        1. Defining the Generator
        2. Defining the Discriminator
        3. Defining the DCGAN
      6. Training GAN
        1. Plot the Training  - 1
        2. Plot the Training - 2
        3. Training Loop
      7. Predictions
        1. CNN classifier predictions on the noised and generated images
      8. Scripts in Modular form
        1. Module 1  - train_mnist.py
        2. Module 2 - training_plots.py
        3. Module 3 - GAN.py
        4. Module 4 - train_gan.py
    3. The conclusion to the project
    4. Summary
  8. 15- Develop an autonomous Agents with Deep R Learning
    1. INTRODUCTION
    2. Let's get to the Code!
    3. Deep Q Learning
      1. Importing all the dependencies
      2. Exploring the Cart-Pole game
        1. Interacting with Cart-Pole game
          1. Loading the Game
          2. Resetting The Game
          3. Playing the Game
        2. Q - Learning
      3. Defining Hyperparameters for DQN
      4. Building the Model Components
        1. Defining the Agent
        2. Defining the Agent Action
        3. Defining the Memory
        4. Defining Performance Plot
        5. Defining Replay
        6. Training Loop
        7. Testing the DQN model
      5. Deep Q learning Scripts in Modular form
        1. Module 1  - hyperparameters_dqn.py
        2. Module 2 - agent_replay_dqn.py
        3. Module 3 - test_dqn.py
        4. Module 4 - train_dqn.py
    4. Deep SARSA Learning
      1. SARSA Learning
        1. Importing all the dependencies
        2. Loading the game Environment
        3. Defining the agent
        4. Training the agent
        5. Testing the agent
      2. Deep SARSA learning Script in Modular form
    5. The conclusion to the project
    6. Summary
3.137.176.166