Cover image for Deep Learning with Structured Data

Deep Learning with Structured Data

Release Date: 2021/01/01
ISBN: 9781617296727
Topic:
0%
17
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

Deep Learning with Structured Data teaches you powerful data analysis techniques for tabular data and relational databases. Get started using a dataset based on the Toronto transit system. As you work through the book, you’ll learn how easy it is to set up tabular data for deep learning, while solving crucial production concerns like deployment and performance monitoring.

Table of Contents

  1. Deep Learning with Structured Data
  2. Copyright
  3. dedication
  4. contents
  5. front matter
    1. acknowledgments
    2. about this book
    3. Who should read this book
    4. How this book is organized: A roadmap
    5. About the code
    6. liveBook discussion forum
    7. about the author
    8. about the cover illustration
  6. 1 Why deep learning with structured data?
    1. 1.1 Overview of deep learning
    2. 1.2 Benefits and drawbacks of deep learning
    3. 1.3 Overview of the deep learning stack
    4. 1.4 Structured vs. unstructured data
    5. 1.5 Objections to deep learning with structured data
    6. 1.6 Why investigate deep learning with a structured data problem?
    7. 1.7 An overview of the code accompanying this book
    8. 1.8 What you need to know
    9. Summary
  7. 2 Introduction to the example problem and Pandas dataframes
    1. 2.1 Development environment options for deep learning
    2. 2.2 Code for exploring Pandas
    3. 2.3 Pandas dataframes in Python
    4. 2.4 Ingesting CSV files into Pandas dataframes
    5. 2.5 Using Pandas to do what you would do with SQL
    6. 2.6 The major example: Predicting streetcar delays
    7. 2.7 Why is a real-world dataset critical for learning about deep learning?
    8. 2.8 Format and scope of the input dataset
    9. 2.9 The destination: An end-to-end solution
    10. 2.10 More details on the code that makes up the solutions
    11. 2.11 Development environments: Vanilla vs. deep-learning-enabled
    12. 2.12 A deeper look at the objections to deep learning
    13. 2.13 How deep learning has become more accessible
    14. 2.14 A first taste of training a deep learning model
    15. Summary
  8. 3 Preparing the data, part 1: Exploring and cleansing the data
    1. 3.1 Code for exploring and cleansing the data
    2. 3.2 Using config files with Python
    3. 3.3 Ingesting XLS files into a Pandas dataframe
    4. 3.4 Using pickle to save your Pandas dataframe from one session to another
    5. 3.5 Exploring the data
    6. 3.6 Categorizing data into continuous, categorical, and text categories
    7. 3.7 Cleaning up problems in the dataset: missing data, errors, and guesses
    8. 3.8 Finding out how much data deep learning needs
    9. Summary
  9. 4 Preparing the data, part 2: Transforming the data
    1. 4.1 Code for preparing and transforming the data
    2. 4.2 Dealing with incorrect values: Routes
    3. 4.3 Why only one substitute for all bad values?
    4. 4.4 Dealing with incorrect values: Vehicles
    5. 4.5 Dealing with inconsistent values: Location
    6. 4.6 Going the distance: Locations
    7. 4.7 Fixing type mismatches
    8. 4.8 Dealing with rows that still contain bad data
    9. 4.9 Creating derived columns
    10. 4.10 Preparing non-numeric data to train a deep learning model
    11. 4.11 Overview of the end-to-end solution
    12. Summary
  10. 5 Preparing and building the model
    1. 5.1 Data leakage and features that are fair game for training the model
    2. 5.2 Domain expertise and minimal scoring tests to prevent data leakage
    3. 5.3 Preventing data leakage in the streetcar delay prediction problem
    4. 5.4 Code for exploring Keras and building the model
    5. 5.5 Deriving the dataframe to use to train the model
    6. 5.6 Transforming the dataframe into the format expected by the Keras model
    7. 5.7 A brief history of Keras and TensorFlow
    8. 5.8 Migrating from TensorFlow 1.x to TensorFlow 2
    9. 5.9 TensorFlow vs. PyTorch
    10. 5.10 The structure of a deep learning model in Keras
    11. 5.11 How the data structure defines the Keras model
    12. 5.12 The power of embeddings
    13. 5.13 Code to build a Keras model automatically based on the data structure
    14. 5.14 Exploring your model
    15. 5.15 Model parameters
    16. Summary
  11. 6 Training the model and running experiments
    1. 6.1 Code for training the deep learning model
    2. 6.2 Reviewing the process of training a deep learning model
    3. 6.3 Reviewing the overall goal of the streetcar delay prediction model
    4. 6.4 Selecting the train, validation, and test datasets
    5. 6.5 Initial training run
    6. 6.6 Measuring the performance of your model
    7. 6.7 Keras callbacks: Getting the best out of your training runs
    8. 6.8 Getting identical results from multiple training runs
    9. 6.9 Shortcuts to scoring
    10. 6.10 Explicitly saving trained models
    11. 6.11 Running a series of training experiments
    12. Summary
  12. 7 More experiments with the trained model
    1. 7.1 Code for more experiments with the model
    2. 7.2 Validating whether removing bad values improves the model
    3. 7.3 Validating whether embeddings for columns improve the performance of the model
    4. 7.4 Comparing the deep learning model with XGBoost
    5. 7.5 Possible next steps for improving the deep learning model
    6. Summary
  13. 8 Deploying the model
    1. 8.1 Overview of model deployment
    2. 8.2 If deployment is so important, why is it so hard?
    3. 8.3 Review of one-off scoring
    4. 8.4 The user experience with web deployment
    5. 8.5 Steps to deploy your model with web deployment
    6. 8.6 Behind the scenes with web deployment
    7. 8.7 The user experience with Facebook Messenger deployment
    8. 8.8 Behind the scenes with Facebook Messenger deployment
    9. 8.9 More background on Rasa
    10. 8.10 Steps to deploy your model in Facebook Messenger with Rasa
    11. 8.11 Introduction to pipelines
    12. 8.12 Defining pipelines in the model training phase
    13. 8.13 Applying pipelines in the scoring phase
    14. 8.14 Maintaining a model after deployment
    15. Summary
  14. 9 Recommended next steps
    1. 9.1 Reviewing what we have covered so far
    2. 9.2 What we could do next with the streetcar delay prediction project
    3. 9.3 Adding location details to the streetcar delay prediction project
    4. 9.4 Training our deep learning model with weather data
    5. 9.5 Adding season or time of day to the streetcar delay prediction project
    6. 9.6 Imputation: An alternative to removing records with bad values
    7. 9.7 Making the web deployment of the streetcar delay prediction model generally available
    8. 9.8 Adapting the streetcar delay prediction model to a new dataset
    9. 9.9 Preparing the dataset and training the model
    10. 9.10 Deploying the model with web deployment
    11. 9.11 Deploying the model with Facebook Messenger
    12. 9.12 Adapting the approach in this book to a different dataset
    13. 9.13 Resources for additional learning
    14. Summary
  15. Appendix. Using Google Colaboratory
    1. A.1 Introduction to Colab
    2. A.2 Making Google Drive available in your Colab session
    3. A.3 Making the repo available in Colab and running notebooks
    4. A.4 Pros and cons of Colab and Paperspace
  16. index
18.118.144.69