Practical Deep Learning Course

Welcome to the GitHub repository for the Practical Deep Learning Course. Here you will find all the code, notebooks, and resources used throughout the course.

Table of Contents

• Repository Content
• How to Run the Code

Repository Content

The content in this repository is divided into five key modules, focusing on various aspects of Deep Learning. Each module includes Jupyter notebooks combining theory, code, and explanations.

• Module 1: Deep Learning Fundamentals: class/Fundamentals

  • First_Model: First neural network — MNIST handwritten digit classification.
  • NN_Fundamentals: Neural network basics with decision boundary visualization on toy datasets.
  • IMBD_sentiment_binary_classification: Binary sentiment classification on movie reviews.
  • Prevent_Overfitting: Regularization techniques (Dropout, L1/L2, Early Stopping) to prevent overfitting.
  • Regression_tuner: Regression with hyperparameter optimization using Keras Tuner.

• Module 2: Convolutional Neural Networks (CNNs): class/CNN

  • Introduction_to_CV_with_Pillow: Image manipulation and processing with Pillow.
  • Introduction_to_CV_with_OpenCV: Computer vision basics using OpenCV.
  • Introduction_to_CNN: Convolution operations, CNN architectures, transfer learning and data augmentation.
  • Classical_Architectures_CNN: Classic CNN architectures (LeNet, AlexNet, VGG, ResNet, Inception).
  • cat_vs_dogs: Binary image classification with hyperparameter tuning.
  • Visualizing_What_CNNs_Learn: Feature maps, Grad-CAM and saliency maps.
  • OCR_with_OpenCV_and_Tesseract: Optical Character Recognition with Tesseract.
  • OCR_with_EasyOCR_and_TrOCR: Modern OCR with EasyOCR and TrOCR (transformer-based).
  • Object_Detection_YOLO_ultralytics: Object detection with YOLO and Ultralytics.
  • Object_Tracking_Counting: Object tracking and counting with YOLO.
  • Siamese_net: Siamese networks for similarity learning.
  • CLIP_Zero_Shot_Classification: Zero-shot image classification with CLIP (no training needed).
  • Image_Segmentation_with_HuggingFace: Skin lesion segmentation with SegFormer and the Hugging Face ecosystem.

• Module 3: Recurrent Neural Networks (RNNs): class/RNN

  • Introduction_to_RNN_Time_Series: RNN fundamentals and time series prediction.
  • IMBD_RNN: Sentiment classification using RNNs.
  • Character-level_text_generation_with_RNN: Character-level text generation.
  • Seq2seq: Sequence-to-sequence models.
  • img2seq: Image-to-sequence model (CAPTCHA solving).

• Module 4: Natural Language Processing (NLP) with Deep Learning: class/NLP

  • Embedding_layer: Word embeddings for text representation.
  • text_classification_rnn: Text classification using RNNs and CNNs.
  • semantic_search_QA_clustering: Semantic search and question-answering with Sentence Transformers.
  • Image_search: Image search using CLIP and Sentence Transformers.

In addition to these practical modules, we provide a brief theoretical overview in the Deep Learning with TensorFlow notebook. This resource offers a concise recap of essential deep learning concepts, acting as a handy reference guide.

How to Run the Code

The Jupyter notebooks provided in this course can be run either locally on your machine or remotely on Google Colab

Running Locally

To install TensorFlow and TensorFlow-hub, run:

pip install tensorflow
pip install --upgrade tensorflow-hub

For more details see TensorFlow installation instructions

To install all the dependencies, run:

pip install -r requirements.txt

Running on Google Colab

You can upload the notebook directly in Google Colab or you can click in the Colab icon at the beginning of each notebook:

Run in Google Colab

View Source on GitHub

Running with Docker

In addition to running the notebooks locally or on Google Colab, you can also run them in a Docker container. This ensures that all dependencies are satisfied in a self-contained environment, which can make it easier to get up and running with the project.

Follow these steps to build and run the Docker image:

Pre-requisites

Install Docker on your machine. You can download it for Mac, Windows, or Linux from the official Docker website.

Building the Docker Image

Open your terminal, navigate to the directory containing the Dockerfile and run the following command to build the Docker image:

docker build -t deep-learning-course .

This command builds an image and tags it as "deep-learning-course".

Running the Docker Image

Run the Docker image with the following command:

docker run -p 4000:8888 deep-learning-course

To persist your changes and have your notebooks saved outside of Docker (on Windows, you might have to replace $(pwd) with ${pwd} or with the full path to your directory):

docker run -p 4000:8888 -v "$(pwd)":/app deep-learning-course

This command maps the port 8888 inside Docker as port 4000 on your machine.

Accessing the Notebooks

Once your Docker image is up and running, you can access the Jupyter notebooks by visiting http://localhost:4000 in your web browser. You'll see a list of notebooks that you can click on to view, run, and interact with.