Academic Databases
Explore Our Semantic Databases
STEM & Tech
Math, Physics, CS & Engineering...
Economics
Macro, Micro, Econometrics...
Business
Management, Marketing, Finance...
Health & Life Sciences
Biology, Medicine, Neuroscience...
Humanities & Social Sciences
Psychology, Law, Philosophy, History...
General Studies
General & interdisciplinary studies...
Explore Topics
Features

TensorFlow 2.0 Tutorial: Getting Started with Keras for Deep Learning

Added: 2026-08-07

Deep Dive

Proficiency in basic Python programming, including data structures, functions, and object-oriented concepts.

10. Python (Basic 2) - Big-Data Analytics

10. Python (Basic 2) - Big-Data Analytics

712

This comprehensive section covers Python's core programming concepts. String operations include startswith(), endswith(), find(), replace(), split(), format(), slicing with negative indices and step parameters, concatenation with +, repetition with *, and indexing with len(). Data structures feature dictionaries with key-value pairs accessed via square brackets, with methods like copy(), items(), keys(), and values(). Functions are defined with def, accept parameters, return values, and have local scope. Object-oriented programming uses classes defined with class keyword, containing methods accessed through instances using dot notation. The self parameter enables methods to access the instance. The __init__() method initializes attributes, while __str__() defines string representation. This foundation enables clean, organized, and reusable code design.

Click to watch →

БАЗА ПИТОНА ЗА ЧАС: Основные понятия

БАЗА ПИТОНА ЗА ЧАС: Основные понятия

1.4K

This section covers Python's data structures and function programming. It begins with lists as ordered collections that can store multiple values of different types, demonstrating zero-based indexing and negative indices. The instructor covers list operations: len(), sort(), append(), insert(), remove(), pop(), clear(), index(), count(), copy(), and reverse(). The section then introduces functions as reusable code blocks defined with def, demonstrating parameter passing and return values. It concludes with module importing using import and from module import function syntax, including examples with random and math modules.

Click to watch →

ستكون محترف بعد هذا الكورس! - بايثون بالعربي - Python High Level Full Tutorial 2025 Arabic

ستكون محترف بعد هذا الكورس! - بايثون بالعربي - Python High Level Full Tutorial 2025 Arabic

13K

This section covers Python's core data structures and advanced programming concepts. The instructor explains lists as ordered collections using square brackets, accessed by zero-based index. Tuples are introduced as immutable collections using parentheses, useful when data shouldn't change. Dictionaries are presented as key-value pairs using curly braces, enabling efficient data retrieval by keys. The section covers functions as reusable code blocks defined with def keyword, taking parameters and returning values. The instructor demonstrates creating functions like def greet(name): print(f'Hello, {name}'). The section covers modules as pre-written code imported using import statement, demonstrating the os module for file system operations. The instructor introduces object-oriented programming (OOP) with classes as blueprints for creating objects that bundle data (attributes) and behavior (methods). The section covers inheritance where classes can inherit from other classes. Understanding these concepts helps organize complex code into manageable, reusable components, making programs more maintainable and efficient.

Click to watch →

Python 01 Basic

Python 01 Basic

284

This section covers Python's built-in data structures including lists, dictionaries, tuples, and sets. It explains how to create, modify, and access elements in each structure. The content also covers functions, modules, and basic object-oriented programming concepts. Understanding data structures is essential for organizing and manipulating data efficiently in Python programs.

Click to watch →

Fresher Mock Interview PYTHON | Technical Round | Python Mock Interview| Fresher Java Mock Interview

Fresher Mock Interview PYTHON | Technical Round | Python Mock Interview| Fresher Java Mock Interview

80.5K

Python is a general-purpose, high-level, object-oriented, interactive, and descriptive programming language that has gained popularity for machine learning, deep learning, and neural networks applications. It supports multiple data types including lists, strings, dictionaries, and tuples, classified as mutable (modifiable after creation) or immutable (cannot be modified). Python programs execute line by line through an interpreter, are platform-independent, and open source. Key concepts include swapping variables using tuple unpacking, understanding .py source files versus .pyc compiled bytecode, and recognizing built-in functions. User-defined functions are created using the 'def' keyword with the return statement for sending values. Python is an object-oriented programming language supporting inheritance (single, multiple, multilevel), encapsulation, polymorphism, and abstraction. Memory is organized as a heap data structure. Exception handling using try-except blocks enables graceful error management.

Click to watch →

Deep Dive

Fundamental understanding of Machine Learning concepts, such as supervised learning, training vs. testing datasets, and basic evaluation metrics like accuracy.

ML 2 : LearnTraining VS Testing Dataset with Examples #machinelearning

ML 2 : LearnTraining VS Testing Dataset with Examples #machinelearning

92.7K

A dataset is a collection of data (e.g., student records with roll numbers, names, subjects, and marks) that can be divided into two essential parts: the training dataset and the testing dataset. The training dataset is used for building and training machine learning models, while the testing dataset is reserved for evaluating model performance. In supervised learning, the training phase requires input in the format of attributes (features) and labels (classifications), enabling the machine to learn patterns and relationships between inputs and outputs. The testing phase uses only attributes without labels to assess whether the trained model can correctly predict outcomes for new, unseen data.

Click to watch →

Deep learning на пальцах 2 - Элементы машинного обучения

Deep learning на пальцах 2 - Элементы машинного обучения

57.8K

This lecture introduces fundamental concepts of supervised machine learning, including the distinction between training and test data, the K-nearest neighbors algorithm, and the critical importance of balancing model complexity to avoid overfitting (memorizing training data) or underfitting (failing to capture patterns). The instructor explains how to use validation sets and cross-validation for hyperparameter tuning, and discusses classification metrics such as accuracy, precision, recall, and F1 score for evaluating model performance on imbalanced datasets.

Click to watch →

Machine Learning Python | Machine Learning Algorithms | Python Tutorial | Edureka

Machine Learning Python | Machine Learning Algorithms | Python Tutorial | Edureka

200.5K

This section covers the two main types of machine learning and the supervised learning process. Supervised learning involves training with inputs and corresponding targets, enabling the machine to predict targets for new inputs after sufficient training. An example is customer segmentation in marketing to determine high and low priority customers. Unsupervised learning involves training only with inputs without targets, allowing the machine to find structures or relationships between different inputs. The supervised learning process consists of two key steps: training (dividing data into training and test sets, using training data to teach the algorithm) and testing (using test data to determine accuracy by comparing predicted outputs with actual outputs).

Click to watch →

Lec-23: Supervised vs Unsupervised learning with real life example

Lec-23: Supervised vs Unsupervised learning with real life example

222.8K

Supervised learning is a machine learning approach where the model learns from labeled data containing input-output pairs. The process involves dividing data into training (70%) and testing (30%) sets, selecting a model (classification or regression), training it on labeled examples, and evaluating its predictive accuracy. Classification predicts categorical outcomes (e.g., rain/no rain), while regression predicts continuous values (e.g., house prices). Real-world applications include weather forecasting, where historical data with temperature, humidity, and precipitation inputs train models to predict future weather conditions.

Click to watch →

Lecture 2 | AI Free Basic Course

Lecture 2 | AI Free Basic Course

307.3K

Supervised learning is a machine learning approach where models learn from labeled input-output pairs, using training data to make predictions on new data through a training mode (learning from feedback) and inference mode (applying learned patterns). A critical concept is overfitting, where models achieve 100% accuracy on training data but fail on new data because they've memorized examples rather than learning generalizable patterns. Effective model development requires splitting data into training (70%) and validation/test (30%) sets to ensure the model generalizes well to unseen data.

Click to watch →

Deep Dive

Familiarity with the NumPy library for data manipulation and working with multi-dimensional arrays (tensors).

Every Python Library / Module Explained in 13 Minutes

Every Python Library / Module Explained in 13 Minutes

465.1K

NumPy (Numerical Python) is a package for scientific computing primarily used for efficiently building multi-dimensional arrays. In vanilla Python, lists store items sequentially but not necessarily contiguously in memory. NumPy ensures all input data is stored contiguously in memory for faster access. A single-dimensional array is a list, while two-dimensional arrays form matrices (grids of rows and columns). Arrays with more than two dimensions are called tensors, and NumPy significantly accelerates data handling compared to standard Python lists.

Click to watch →

15- NumPy in Python for Data Science (Day-7a) | #python_ka_chilla #baba_aammar

15- NumPy in Python for Data Science (Day-7a) | #python_ka_chilla #baba_aammar

15.6K

NumPy is a fundamental Python library for data science that provides efficient numerical operations through multi-dimensional arrays, which are faster than Python lists for mathematical and statistical computations; arrays can be one-dimensional (vectors), two-dimensional (matrices), or three-dimensional (tensors), and are created using the np.array() function with proper indexing and slicing techniques for data manipulation.

Click to watch →

Session 13 - Numpy Fundamentals | Data Science Mentorship Program (DSMP) 2022-23 | Free Session

Session 13 - Numpy Fundamentals | Data Science Mentorship Program (DSMP) 2022-23 | Free Session

225.1K

NumPy is a fundamental package for scientific computing in Python. It provides multi-dimensional array objects and various derived objects like matrices and masked arrays. The library offers routines for fast operations on arrays including mathematical, logical, sorting, selecting, input/output, Fourier transform, basic linear algebra, basic statistics, random simulation, and more. The core object in NumPy is the ndarray (NumPy array), which serves as the primary data structure for numerical computations.

Click to watch →

NumPy for Beginners in 15 minutes | Python Crash Course

NumPy for Beginners in 15 minutes | Python Crash Course

79.3K

NumPy is a fundamental Python library for numerical computing that enables efficient manipulation of n-dimensional arrays, providing essential functions for creating arrays (using methods like np.random.rand, np.zeros, np.full, and np.array), performing mathematical operations (addition, subtraction, multiplication, division, dot product, and statistical functions like min, max, sqrt, abs, power, log, exp), and managing array data through reading attributes (shape, size, dtype), updating values, sorting, reshaping, appending, inserting, and exporting arrays for use in data science workflows with libraries like TensorFlow, Keras, and pandas.

Click to watch →

NumPy Crash Course - Complete Tutorial

NumPy Crash Course - Complete Tutorial

150.4K

NumPy is the core library for scientific computing in Python, providing high-performance multi-dimensional arrays that enable efficient mathematical operations, element-wise computations, and linear algebra functions, making it essential for data science and machine learning workflows.

Click to watch →

Deep Dive

Basic knowledge of mathematics for deep learning, specifically matrix multiplication (linear algebra) and the concept of gradient descent (calculus).

Gradient Descent - THE MATH YOU SHOULD KNOW

Gradient Descent - THE MATH YOU SHOULD KNOW

19.6K

Gradient descent is a first-order iterative optimization technique requiring only first-order gradients (Jacobian) for weight updates, making it computationally efficient compared to second-order methods that require Hessian matrices. The update rule adjusts parameters by subtracting the gradient scaled by learning rate alpha. Matrix calculus rules are essential: the derivative of a scalar with respect to a column vector produces a row vector, while the derivative of one vector with respect to another produces a Jacobian matrix with denominator expanding along columns and numerator along rows. Basic differentiation rules including logarithmic (d/dx log(x) = 1/x), exponential (d/dx e^x = e^x), and chain rule are also fundamental for gradient computation.

Click to watch →

04 22 Linear Algebra For Deep Learning

04 22 Linear Algebra For Deep Learning

118

Matrix multiplication is the most frequently performed linear algebra operation in deep learning. For two matrices to be multiplied, the number of columns in the first matrix must equal the number of rows in the second matrix. This requirement exists because matrix multiplication involves dot product calculations between columns of the second matrix and rows of the first matrix, not elementwise multiplication. The result of multiplying an M×N matrix with an N×P matrix is an M×P matrix. This operation is fundamental to neural networks as it enables the linear combination of input features with weights.

Click to watch →

DL 2.0. Mathematics for Deep Learning - Introduction | Deep Learning Course

DL 2.0. Mathematics for Deep Learning - Introduction | Deep Learning Course

1.9K

Deep learning requires understanding four core mathematical areas: linear algebra (vectors and matrices for storing weights and performing transformations), statistics (descriptive and inferential for data analysis and predictive modeling), probability theory (for making probabilistic classifications and understanding data distributions), and calculus (derivatives and chain rule for optimization algorithms like gradient descent and backpropagation).

Click to watch →

Kernel benchmarking for PufferLib 4.0

Kernel benchmarking for PufferLib 4.0

390

Essential math for deep learning includes: linear algebra (good first college course, engineering courses are less abstract), multivariate derivative calculus (partial derivatives, matrix derivatives), and integral calculus (comes up less often). Most autograd is based on chain rule for partial derivatives. Programming competence is more likely to bottleneck than math ability. The speaker recommends starting with a good first college course in linear algebra, which could be from the math department or engineering courses.

Click to watch →

[의료 인공지능 전문가 양성과정] Mathematics for Deep Learning v1

[의료 인공지능 전문가 양성과정] Mathematics for Deep Learning v1

444

This comprehensive lecture covers the mathematical foundations essential for deep learning. It begins with calculus fundamentals: functions mapping inputs to outputs, derivatives measuring instantaneous rates of change, and Taylor series for function approximation. The section extends to multivariable calculus, introducing partial derivatives and gradients as vectors containing all partial derivatives. Linear algebra concepts include vectors, vector spaces, matrices, linear combinations, linear independence, basis, and dimension. Linear functions satisfy f(x+y) = f(x) + f(y) and f(cx) = c*f(x), represented by matrices. Vector norms (L1, L2, L∞) measure magnitude. Distance metrics must satisfy non-negativity, identity, symmetry, and triangle inequality. Inner products measure vector similarity. Eigenvalues and eigenvectors reveal matrix structure through Av = λv, found via characteristic equation det(A - λI) = 0. Neural networks consist of layers applying linear transformations followed by non-linear activation functions (sigmoid, tanh, ReLU). Gradient descent minimizes loss functions by iteratively updating parameters: θ_new = θ_old - α∇L(θ). Computational graphs represent mathematical expressions as directed graphs, enabling automatic differentiation. Backpropagation applies the chain rule in reverse to compute gradients efficiently. Multiplication nodes distribute gradients, addition nodes pass them unchanged. This framework enables training of deep neural networks by automating complex gradient computations.

Click to watch →

TF 2.0 Intro

Why TF 2.0

Key Changes

Environment Setup

Dataset Loading

Data Exploration

Data Preprocess

Model Building

Model Compile

Model Eval

TF 2.0 Intro

0:00

Playing Section

1
Launches deep learning series using TensorFlow 2.0.
2
Highlights Google's promise of improved API consistency.
3
Will use fashion MNIST dataset for the tutorial.

Deep Dive

Exploring Convolutional Neural Networks (CNNs) to achieve significantly higher accuracy on image datasets like Fashion MNIST.

Create Your First Deep Learning CNN Model And Achieve Above 99% Accuracy On MNIST Dataset

Create Your First Deep Learning CNN Model And Achieve Above 99% Accuracy On MNIST Dataset

248

A Convolutional Neural Network (CNN) can achieve over 99% accuracy on the MNIST handwritten digit classification dataset by using multiple convolutional layers with increasing filter sizes (32, 64, 128), ReLU activation, max pooling, dropout regularization, and a dense output layer with softmax activation, where the model learns hierarchical features from raw pixel data through convolution and pooling operations.

Click to watch →

23.4.معماری‌های رایج شبکه‌های عصبی پیچشی

23.4.معماری‌های رایج شبکه‌های عصبی پیچشی

308

A basic CNN for fashion MNIST uses default parameters (3x3 kernel, ReLU activation, normal weight initialization) and consists of: three convolutional layers with 64, 128, and 256 filters respectively, each followed by max pooling, a flatten layer, three dense layers (128, 64, 10 units), dropout layers (50% probability) to prevent overfitting, and a softmax output layer. This architecture achieves approximately 92% accuracy on fashion MNIST, demonstrating how CNNs outperform traditional fully connected networks for image classification tasks.

Click to watch →

‫پروژه کامل شبکه عصبی کانولوشنی (CNN) با توضیحات کامل تمامی مراحل پیاده سازی و لایه های شبکه

‫پروژه کامل شبکه عصبی کانولوشنی (CNN) با توضیحات کامل تمامی مراحل پیاده سازی و لایه های شبکه

3.9K

This comprehensive tutorial covers the complete workflow of building and comparing Convolutional Neural Networks (CNNs) for image classification. The project uses the Fashion MNIST dataset (70,000 images of clothing and footwear across 10 classes) to demonstrate practical CNN implementation. Key topics include: loading and preprocessing data (normalization to 0-1 range), building standard dense neural networks with dense layers, ReLU activation, and Softmax output, and constructing CNN architectures with Conv2D layers, MaxPooling/AveragePooling layers, Flatten layers, and dense layers. The tutorial demonstrates that CNNs achieve better performance (92.71% validation accuracy vs 90% for dense networks) and converge faster (220 epochs vs more epochs) due to their ability to learn spatial hierarchies of features directly from raw pixel data. The comparison also covers training dynamics, validation accuracy, and overfitting detection through training vs validation accuracy comparison.

Click to watch →

Keras Convolutional Neural Neural Networks for MNIST and Fashion MNIST (6.2)

Keras Convolutional Neural Neural Networks for MNIST and Fashion MNIST (6.2)

11.4K

Convolutional Neural Networks (CNNs) are specialized neural networks designed for image processing that use convolution layers with filters to automatically learn spatial hierarchies of features from images, followed by max pooling layers to reduce dimensionality and achieve positional invariance, making them highly effective for computer vision tasks such as classifying handwritten digits (MNIST) and fashion items (Fashion MNIST).

Click to watch →

Convolutional Neural Networks from Scratch | In Depth

Convolutional Neural Networks from Scratch | In Depth

141.8K

A convolutional neural network processes images through sequential layers: input layer (28x28x1 grayscale image), first convolutional layer with 2 filters (5x5x1), ReLU activation, max pooling (2x2, stride 2), second convolutional layer with 4 filters (3x3x2), sigmoid activation, max pooling again, flattening to 100 nodes, and finally a fully connected output layer with 10 predictions. The model achieves 95.4% accuracy on MNIST data.

Click to watch →

Deep Dive

Mastering hyperparameter tuning and regularization techniques, such as Dropout, Batch Normalization, and L1/L2 regularization to prevent overfitting.

Deep Learning Hyperparameter Tuning in Python, TensorFlow & Keras

Deep Learning Hyperparameter Tuning in Python, TensorFlow & Keras

25.6K

Overfitting occurs when models specialize too much to training data, indicated by high training accuracy but lower validation accuracy. Two primary regularization techniques combat this: (1) L2 regularization adds a penalty term to the loss function, controlled by lambda (λ), driving weights toward zero to reduce model complexity; (2) Dropout randomly deactivates neurons during training (e.g., 5% dropout rate), forcing redundant representations and preventing specialization. Both techniques are applied during training only. The demonstration shows applying L2 regularization (λ=0.001) and dropout (rate=0.05) to a 128-node model, achieving ~97.8% validation accuracy compared to ~99% without regularization.

Click to watch →

Week 2 – Lecture: Stochastic gradient descent and backpropagation

Week 2 – Lecture: Stochastic gradient descent and backpropagation

58.2K

Regularization prevents overfitting by adding penalties to the loss function. L2 regularization (weight decay) adds λ||W||², shrinking weights toward zero proportionally: W_new = W_old × (1-αλ) - α∇L. L1 regularization adds λ∑|W|, driving some weights exactly to zero and creating sparse representations. Dropout randomly sets neuron outputs to zero during training (typically 50%), forcing distributed information encoding. During testing, outputs are scaled by dropout rate. Proper weight initialization (He initialization: variance 1/n_in) ensures stable signal propagation through deep networks, preventing vanishing/exploding gradients.

Click to watch →

Foundations of Deep Learning (Hugo Larochelle, Twitter)

Foundations of Deep Learning (Hugo Larochelle, Twitter)

47.9K

Dropout and batch normalization are essential techniques for training deep neural networks. Dropout randomly deactivates hidden units during training (probability p=0.5) to prevent co-adaptation, then scales activations by p at test time. Batch normalization normalizes pre-activations within mini-batches, applies learned shifts/scales, and reduces internal covariate shift. Both techniques improve optimization dynamics and serve as implicit regularizers, with batch normalization sometimes reducing dropout's effectiveness.

Click to watch →

Introdução ao Deep Learning - Dia 2

Introdução ao Deep Learning - Dia 2

967

Regularization techniques prevent overfitting by constraining model complexity. Dropout randomly 'drops out' (sets to zero) a proportion of neurons during training, preventing neurons from co-adapting too much and forcing the network to learn more robust features. Early stopping monitors validation performance and stops training when validation error stops improving. L1 and L2 regularization add penalty terms to the cost function: L2 (Ridge) adds a penalty proportional to the square of weights, encouraging smaller weights; L1 (Lasso) adds a penalty proportional to absolute values, encouraging sparse solutions where some weights become exactly zero.

Click to watch →

Lecture 10: Training Neural Networks I

Lecture 10: Training Neural Networks I

41.7K

Regularization prevents overfitting and enables training deeper networks. L2 regularization (weight decay) penalizes large weights, reducing model complexity. Dropout introduces randomness during training by zeroing random neurons (probability p), forcing redundant representations and preventing co-adaptation; at test time, outputs are scaled by 1/p. Inverted dropout applies scaling during training. Batch normalization adds randomness through per-batch statistics computation, then averages them at test time. Both dropout and batch normalization follow the pattern of adding randomness during training and marginalizing it at test time. Modern architectures like ResNet prefer batch normalization over dropout, combined with L2 weight decay. Data augmentation applies label-preserving transformations during training and averages predictions at test time, effectively multiplying training data size. Advanced variants include DropConnect, fractional pooling, stochastic depth, cutout, and mixup.

Click to watch →

Deep Dive

Transitioning from the Keras Sequential API to the Functional API and Model Subclassing for building complex, non-linear network topologies.

Deep learning with Python - Chapter 7 - 7.2 - Keras sequential vs functional API

Deep learning with Python - Chapter 7 - 7.2 - Keras sequential vs functional API

29.8K

Keras offers two APIs for creating neural network models: the Sequential API, which is simpler and easier for basic models by stacking layers linearly, and the Functional API, which is more powerful and flexible for complex architectures like residual neural networks by allowing layers to connect in non-linear ways through a directed acyclic graph; while both can create equivalent simple models, the Functional API is recommended for advanced model designs despite being more complex to implement.

Click to watch →

Keras: Shortcut to AI mastery

Keras: Shortcut to AI mastery

3.2K

Keras 3 introduces framework optionality, allowing it to work with any backend including TensorFlow, JAX, PyTorch, or NumPy through the Keras backend environment variable. Keras layers serve as fundamental building blocks of models, functioning as nodes in a computational graph with variables and forward pass logic. Three APIs exist for model creation: Sequential API for simple linear stacks, Functional API for flexible models with multiple inputs/outputs and non-linear topologies, and Subclassing API for custom model implementations. The Functional API is recommended for most use cases due to its clarity and flexibility. Models can be sliced to extract sub-models by specifying input and output layers.

Click to watch →

Text Classification Using BERT & Tensorflow | Deep Learning Tutorial 47 (Tensorflow, Keras & Python)

Text Classification Using BERT & Tensorflow | Deep Learning Tutorial 47 (Tensorflow, Keras & Python)

191.7K

Keras provides two model-building approaches: Sequential API (adding layers one after another in sequence) and Functional API (defining layers as functions with explicit input/output connections). The Functional API allows more flexibility including multiple inputs/outputs, shared layers between models, and complex architectures like ResNet, making it suitable for advanced model designs.

Click to watch →

Module 6- part1- Neural Network basics for timeseries forecasting

Module 6- part1- Neural Network basics for timeseries forecasting

850

TensorFlow/Keras provides three approaches for building neural networks: (1) Sequential API: The simplest approach where layers are added sequentially to a model object. It is easy to use but least flexible, suitable for beginners and straightforward architectures. (2) Functional API: More flexible than sequential, allowing customization of individual layers and connections between them. It provides greater control over model architecture while maintaining access to built-in Keras capabilities. (3) Subclassing API: The most flexible approach where users define custom model classes by subclassing tf.keras.Model. This requires implementing call() methods and offers maximum flexibility but is more error-prone and complex. For this course, we start with Sequential and progress to Functional API as needed.

Click to watch →

Lesson 5: Practical Deep Learning for Coders

Lesson 5: Practical Deep Learning for Coders

37.2K

The Functional API enables architectures impossible with Sequential API, including multiple inputs and branching paths. It defines models by specifying inputs and explicitly connecting layers. For collaborative filtering, this means creating separate sub-models for user and movie embeddings, then merging them via dot product and bias addition. The merge function combines outputs, and the final model specifies accepted inputs and outputs. This approach is essential for models requiring multiple inputs or complex topologies.

Click to watch →

Deep Dive

Learning model deployment workflows, including saving models, loading them for inference, and using TensorFlow Serving or TensorFlow Lite.

4.1 Deploying TensorFlow Models: Saving and Loading Models

4.1 Deploying TensorFlow Models: Saving and Loading Models

384

Deploying TensorFlow models requires saving trained models to disk and loading them for inference in production environments. TensorFlow provides multiple saving methods: saving the entire model (architecture, weights, and optimizer state) in a single HDF5 file using model.save(), or saving the architecture separately to JSON/YAML files and weights to separate HDF5 files using model.to_json() and model.save_weights(). Correspondingly, models can be loaded using load_model() for entire models or by loading architecture from JSON/YAML and weights from HDF5 files separately. Critical considerations include ensuring version compatibility between TensorFlow and Keras, as API changes can cause incompatibility, and selecting appropriate serialization formats (HDF5, JSON, or Protocol Buffers) based on deployment requirements such as file size, interoperability, and ease of use.

Click to watch →

Deploying production ML models with TensorFlow Serving overview

Deploying production ML models with TensorFlow Serving overview

21.5K

TensorFlow Serving is a high-performance serving infrastructure that enables deploying machine learning models into production with low latency and high throughput, supporting multiple models and versions, REST/gRPC protocols, GPU acceleration, and integration with Docker and Kubernetes; the deployment workflow involves training the model, exporting it in SavedModel format, starting the TF Serving server, and sending inference requests to make business decisions based on model outputs.

Click to watch →

Machine Learning Zero to Hero (Google I/O'19)

Machine Learning Zero to Hero (Google I/O'19)

1.8M

Deploying machine learning models requires serializing them into portable formats. TensorFlow's SavedModel captures the complete model graph, variables, and weights for deployment. TensorFlow Serving provides production-grade inference with gRPC/REST interfaces for web applications. TensorFlow Lite converts models for mobile and edge devices (Raspberry Pi, Edge TPUs), enabling on-device inference without internet connectivity. This complete pipeline—from training through deployment—enables bringing machine learning models into production environments efficiently.

Click to watch →

TensorFlow Lite (TensorFlow @ O’Reilly AI Conference, San Francisco '18)

TensorFlow Lite (TensorFlow @ O’Reilly AI Conference, San Francisco '18)

4.6K

TensorFlow Lite offers two engagement levels: 'dipping toes' with pre-built demos and pre-trained models, and 'full swimming' with complete model development. The deployment workflow consists of four steps: building and training the model, converting to TensorFlow Lite format, validating the converted model, and deploying across supported platforms. Users can leverage pre-trained models for immediate deployment, or customize models through retraining workflows that collect examples, train on new data, convert to TensorFlow Lite, and deploy the optimized model. Multiple APIs support deployment including Python, C++, Java, C, and experimental C# for Unity integration.

Click to watch →

How to Deploy a Tensorflow Model to Production

How to Deploy a Tensorflow Model to Production

119K

The deployment process involves training a model (e.g., MNIST digit recognition with single-layer network, softmax, cross-entropy loss, mini-batch gradient descent), saving it using SavedModelBuilder to create a servable snapshot, and defining signature maps for inputs, outputs, and components. Setting up TensorFlow Serving requires cloning the repository, building a Docker image containing all dependencies (Python, TensorFlow, gRPC, bazel), configuring with bazel configure, and building with bazel build (20-50 minutes). For inference, download pre-trained models like Inception (won 2014 ImageNet competition) and convert to checkpoint format. Running locally uses the model_server command with model name and path parameters.

Click to watch →

TF 2.0 Intro

Why TF 2.0

Key Changes

Environment Setup

Dataset Loading

Data Exploration

Data Preprocess

Model Building

Model Compile

Model Eval

TF 2.0 Intro

0:00

Playing Section

1
Launches deep learning series using TensorFlow 2.0.
2
Highlights Google's promise of improved API consistency.
3
Will use fashion MNIST dataset for the tutorial.

58.2K views56238:53@KGPTalkieOriginal Release: 2019-08-28

TensorFlow 2.0 is Google's most popular deep learning library that works in three parts: data preprocessing, model building, and training/evaluation. It takes input as multi-dimensional arrays called tensors. The key improvements in TensorFlow 2.0 include cleaner APIs, eager execution for Pythonic code, and Keras integration at the core, which improves productivity and execution speed. The tutorial demonstrates building a neural network model using the Sequential API with Flatten, Dense, and output layers, compiling with loss function (sparse categorical cross-entropy), optimizer (Adam), and metrics (accuracy), then training and evaluating on the Fashion MNIST dataset to achieve approximately 88% test accuracy.

[00:00:00]hi this is let's make antibody in this lesson I'm gonna start a very new video series on a deep learning so in the very first lesson I'm gonna start a deep learning with the tensorflow 2.0 okay so the tensorflow 2.0 - recently had it has been launched by the google and the google has promised so many you know and so many advantage of a tensorflow 2.0 over a tensorflow one point X so this we will be learning initially we will be learning just the introduction of tensorflow and how and why we should huge tensorflow 2.0 and then we will be working with the amnesty data set throughout this tutorial and then i'll show you how you can import the image dataset and then after that I'll show you how you can do some data exploration and after that I'll show you how you can build a model with tensorflow 2.0 and the Charis with the high level API and then finally how you can compile and then how you can train your model the maximum testing accuracy is training accuracy is 91% and the testing accuracy is 88% which shows that the model is overfitting somehow okay so this will be the all in this lesson before I start this lesson I would like to tell you one more thing you can go ahead at my channel kgp talkie and at the KGB talkie I have met so many videos I have basically made on the three basic topics the first topic was Python getting started so there I have covered the pandas numpy matplotlib Seabourn data visualization and then the second part of the lessons was on a classical machine learning like linear regression logistic regression K and in SVM decision tree random forest PC in symbol learning etc and the learning curve and then the third was based on a feature selection so I have selected the feature based on the filter methods wrapper methods and embedded methods as well as with the linear discriminate analysis and principal component analysis okay now come back to this lesson without wasting a time let's go ahead and start a brand you listen on a tensorflow 2.0 since this is a very sort and quick listen on a tensorflow 2.0 so angrily I'm gonna take a very quickly at through the part then I'll start a coating on this so once we start on the tensorflow the first come in our mind what is the tensor flow right so the currently the tensor flow is the most famous deep learning library in the world and Creech developed via Google the Google product uses machine learning in all of its product to improve the search engine translation image captionings recommendations moreover the Google do all these things to improve the user experience right so this tensor flow architecture works in the three parts the first it pre-process the data then it build the model and then finally train and estimate the models that's mean it train the model and then evaluate the performance of the model right and it is called the tensor flow because it takes input as a multi-dimensional array which is also known as a tensor that's why it is known as a tensor flow now the very quickly let's go ahead why every data scientist learns tensor flow to point X the currently the Google has released the tensor flow 2.0 the RC version which is the release candidate and why we should leave it in the flow one point X there are so many things which Google had changed into a tensor flow 2.0 okay so the tensor flow 2.0 make the users more productive including the are removing the redundant API and making API a more consistent the tensor flow one point X has many api's and the most of them were threatened dn't and the more I and the many times users get confused the data scientists get confused which is the best way and how to use those api's to get the better accuracy that means we had some let us say the particular task and for that particular task there were so many api's and the data scientists we're getting confused which API will be the best for their the data and for their model so in the tensorflow 2.0 the google has the deprecated and removed all those all those api's so the more overt google has done the api cleaner and it has uses the eager execution which is a pythonic breast moreover and it improves the execution time and while defining the variables now in the tensorflow 2.0 it doesn't Eugene into global variables and the tensorflow 2.0 has also removed this essence the earlier in tensorflow we had to use the system dot run and now the tensorflow 2.0 is kindly kind of bringing it like a function call and moreover now the tensor flew to point X R to find zero brings the clearance at the core of the tensor flow which ultimately increases the you know improves the accuracy that that actually can increase the accuracy but that is not 100% sure that that increases the accuracy but moreover it reduced the training and the testing time since the Kira's has been integrated with the core of the tensor flow and in that case the its execution will be the faster actually and it also takes a less space and moreover it is the consistent and if you want to know more about the tensor flow 2.0 what I it is offering you can go ahead and visit this link it has Google IO link there and at the Google i/o you can you know to see this the complete the getting started with the tensor flow 2.0 at the Google i/o so the air google has released this tensor flow 2.0 and they have covered almost everything what is the new in the tensor flow 2.0 there are so many things to the new into the tensorflow 2.0 although this is the new video series and we will be learning a lot about the tensorflow 2.0 throughout this video series now the let's go ahead the very quickly and I'm assuming that you have already installed the an akuna at the necessary library only you need to install the tensorflow and if you do remember the previously you need to install the chaos and the tensorflow separately but here you only need to install that cancer flow you actually don't need to install the Kiera's so you can call the pip install tensorflow equal to equal to the 2.0 RC and you can go ahead to this github link where you can get the tensorflow the released okay so here we have a tensorflow 2.0 and you can visit that I think with this yes so here we have a you know the latest tensorflow the 2.0 this this one is the not the latest one although with the website if you go and visit on the website there you will get a latest one the tensorflow 2.0 the release candidate is available and you just go ahead there you will get the link here to install this so you can keep monitoring this mission this link to get the updated version by the time I'm making this video this is the latest version now let's go ahead and open anaconda into administrator mode remember you need to open it into the administrator mode otherwise it would not be able to install the tensorflow 2.0 in your computer because of the right permission now let's go ahead and copy this which I can just copy it and in the anaconda right the pressing the right click it will paste here the PIP installed tensorflow equal to equal to two point zero point zero RC 0 that if the release candidate 0 let's go ahead and hit the enter although I have already installed the tensorflow 2.0 that's why it is saying that the all the requirement has been already satisfied but if you do not have the tensorflow 2.0 installed in your computer you can install and the moreover if you get the any error then you can first uninstall the previous tensorflow for that you can right there pip uninstalled tensorflow so it will uninstall your previous versions and then you can install a new version of a tensorflow okay perfect now let's go ahead and see if you have a GPU in your computer then you can also install a GPU version of a tensorflow right so these are the two ways where you can install a tensorflow in your computer now you can pause the video and pause this video and that you can continue this video after installing the tensorflow 2.0 alright now let's go ahead import the fashion mms data set so in this lesson we will be working on the finest fashion m-miss data set the fashion m needs to data set the link is available here and this working we working file is available in the video description from where you can download and if you visit this fashion m niche then you see here on the github the link is available and on the github it says that this is Jolanda article images it has 60 thousands examples and every sample have 20 28 cross 28 grayscale images and so these are the images and it has a 10 actually it has two total the ten classes and that's mean there are 10 type of the the fashion images are of level in this fashion amidst dataset okay so these are the images which are available and and and and this sixty thousand images which we will be using to train and ten thousand images to we'll be using to evaluate and it has total the ten categories of these images ok now let's go ahead and first import our learner now first let's go ahead and import the tensorflow and then I'll show you how you can download this the amnesty data set directly into your Jupiters notebook instead of downloading it from a geek health ok / pets to import the tensorflow you need to write their the import and then the tensorflow there we have a tensor flow as usual tensor flow as DF and then we need to improve the care as from the tensor flow so here we have a from tensor flow import the Kira's okay so now we have got sorry we have got the tensor flow and in the chaos sorry yeah now we have imported the Kira's from a tensor flow now let's go ahead and import other necessary libraries like numpy pandas and the matplotlib so those things we can say that a helper liability but before that let's go ahead and check a tensor flow version which you can just check from a print T F dot version so this says that we have Overson 2.0 installed in my computer now let's go ahead and import helper libraries like an umpire Pentagon the matplotlib so in the previous videos we have been importing these libraries very frequently numpy as in P and import pandas HPD and then import might float lib dot type lot as PLT so here we have matplotlib i the pandas and the numpy imported in our computer so these things we can treat as a helper libraries now let's go ahead and load the amnesty person dataset so for that i can write here the amidst is equal to the Kyra's dot datasets and then I can write there the fashion I'm honest so with this we will get a pass anemones dataset although I have already downloaded it my computer otherwise it might take a little time in your computer to download this data set from a internet that might take a few seconds if you have a fast internet now let's go ahead and check the type of the immunised this says that with this immunised actually it has downloaded the data sets in a tensor flow module wrapper now what we need to do now we need to actually load the data now we need to load this data into into a real real variables in this jupiter notebook and to do that it actually returns a tuple ok the two tuples wonderful for the training and another tougher for the testing so for this what we can do here the m in each dot a load data set as usual we have been doing into a scalar now in this topple we need to first down get the data into our our the training dataset that is the extreme and then finally Whiterun and the next couple in the next it returns the testing data sets it has X underscore test and then Y underscore test so it has a 60,000 rows for a training which we can verify that with X train dot safe now there you see here there are 60,000 images are available there and each images have 28 cross 28 some since there are 60,000 images that's mean it should have a 60,000 y train as well so let's go ahead and check the safe of Y trend which says that it has a 60,000 okay now let's go ahead and print the X train and see what happens once we print the extreme we see the values the most of the values we are printing here 0 that is because you note at the ages since this is the grayscale so at the edges the most of the images values are 0 otherwise the maximum value inside this the area which we can find that within P dot max okay so that's it the 255 so the minimum we have already seen in there and that that is the zero but here are the max is 255 and if we see the average that's mean the N P dot mean the X train so it says that something so moreover now we can we can say that the values is somewhere in between 0 and the 255 okay inside this data set which we later we need to bring down in between 0 and 1 to train with the tensor flow tensor flow model okay our deep learning model and these 60,000 images are classified into ten labels and those labels are encoded into a numerical values and those numerical values we can see with the Y under escort rain and those numerical values are in between 0 & 1 sorry 0 1 9 okay so it starts from the 0 until the 9 so those are the 10 categories there now let's go ahead and write those category names although you can get on the pass and M minister's category names there you should get those category names somewhere here yes which category names are here okay so these are the desert trouser pullover dress code sandal cert sneaker back at the ankle board now let's go ahead and and write that the class names here so that we can write in new variable the class name and inside those class name we need to write it okay the desert sign the topic cetera like here we have let us go at the top and the Ender when we have here at rapture and then here we have the pullover and then here we have dress then we have a court and then finally we have the sandal and then we have a cert and then we have a sneaker and then after that we have back sorry it's bad actually not a bad and then we have ankle boot so these are dipped in classes right now let's go ahead and do some the the data exploration so with this data exploration we can actually understand our data in in more explode way okay so since we already have seen its you know the same etc so here if we see the X underscore the train dot say we have 60,000 images but if we see here X underscore test dot safe there we see we have just 10,000 images so this 60,000 images is available for a training and these 10,000 images available for testing purpose so that we can test our model and we can see how accurate our model is performing now let us go ahead and visualize the visualize the data some images so we can visualize that with the PLT so here we have a PLT door failure and then we have a PLT dot image so that's the I am so and inside that we are gonna the see first image okay that is the extreme zero and then I'm gonna just see it and now you will see here it has this image okay so this is actually the boot okay and how would you know this is boot and if we if we print here the X screen actually there you see its nine number and at the nine number you see here we have ankle boot okay so this is the word and if we see here one number and now you see had the one number it's a zero and at the zero it is at top okay so this is how we can visualize and if we print here a color bar at the side okay so we can just right there the color bar okay so with the color bar now you see we have here a color bar and this color bar now you see the value is somewhere in between 0 and the 255 since since neural network model doesn't take the value greater than the one that's mean we need to bring down this the value in the maximum value the 255 in between somewhere 0 and 1 so what we can do to bring it down we can just divide the value with 255 I mean the training and the testing data set with the 255 so we can get here with X underscore X underscore train dot sorry X underscore train is equal to X underscore sorry X underscore train and then divide it by two fifty five point zero okay perfect all right so we have got the extreme in between 0 and the 1 and similarly let's go ahead and bring the X test in between 0 & 1 which we can get by dividing X test by 255 point 0 so with this we have got our X train and the X test in between and in in between the 0 to 25 and what we can do we can just copy it although you need to use your keyboard control and the C and let's go ahead and paste it here and see what happens now now with this you can see here we have brought it down in between 0 and one okay so now this this value is now ready to feed into into into a neural network and one more thing you might have noticed that this size it's a size is 28 cross 28 that's mean there are 28 pixels and these are the pixels which you can see okay so these are the pixels a square dot there so these are the 28 dots here and the 28 is here okay perfect now let's go ahead now build a model a machine learning model with the tensorflow 2.0 with the f 2.0 okay so so so in this what we are going to do the basic building blocks in any neural network is a neural network layers okay so the lyric extracts the representation from the data and Anthony peered into into into it's a hidden layer actually and then finally it starts the training okay so although this is the very critical instance on the tensorflow 2.0 and I'm assuming that you know a little about the neural network so basically you understand how the neural network works so let's go ahead and import the sequential and the dense model sequential and the dense layers from tensorflow Kira's to do that what we can do the front ends are flow from the tensorflow dot Kira's import sequential and then from tensorflow dot dot Kira's and then got layers import and from here I'm gonna import the flatten layer that will be used as a first layer and then dense layer so we have got the two layer and flatten and the dense and the sequential model now let's go ahead and create our model so here we are gonna build our model with the sequential model so here we have a sequence here and then we are gonna pass here ready okay so so the area means the how many are the layers we need inside our sequential model there are many ways to build this but I think this is the simplest way where we can add all these together otherwise there are a few other ways like like just defining first sequential and then going with the model dot add we can go ahead with that one as well like model dot add and then we can add there the first flatten layer there and inside the flatten layer the input shape okay which we are gonna use here input shape will be the 28 cross a 28 there okay so this is an input safe for our the flatten layer the flat hair doesn't do anything actually it's just transformed the the formats of this data which is 28 cross to 28 so this this layer just transformed this data into a one dimensional so that we can fit into the next layer okay so the next layer which I'm gonna add here in the model dot and that is a dense layer okay so this is just a dense layer and inside the dense layer if you press your sift and double tab you will get here detail the documentation on it so in this I'm gonna pass the number of units that's been the number of nodes how many the neural neurons actually we want and then we will pass here the activation function which activation function we are gonna use I'll be taking a different lessons where I will be covering all these things in a very detail this is a very quick lesson so I'm not going to cover all those things here in the detail so activations we will be using and other things we will be just passing as usual okay so other things will be like yeah other things will be a default actually so here in the dense layer I am gonna pass here the 128 new rooms at the firstly and the activation function which we had talked there that I'm gonna use here a raloo activation so this is kind of the detective higher the activation function there are so many other kind of activation function like a sigmoid an edge and you know the Rayleigh key relive all those so here for this listen I'm just gonna use your a loop and then the model dot ad and then again I'm gonna use the output layer in an output layer if you add the output layer then we need to define the how many outputs are there that's when the total number of classes we have a ten classes that's when we have to define here the ten and the activation function here so at the output the real you activation things an activation cannot be used so there at the output either we can use the sigmoid or softmax so here we are gonna use a soft max okay so here we have a model now let's go ahead and print the summary on this model and then you might understand how it is building so the first model has transformed a two-dimensional data into a single dimensional and then here we have 128-bit 128 neurons so 128 and then multiplied by that 784 its complexity reaches the number of parameters actually then reaches to these digits okay so that is the hundred thousands and then finally at the output we are bringing it down to the ten okay jester ten so we have number of parameters at the final output to calculate it the twelve hundred and ninety okay so the total parameter which we which this model will be executing is more than 100,000 okay so this is how we build the model now we need to compile our model okay so for compliation of the model there are a few things which are really very important okay the first which need we need to actually define sorry we need to convert it into a markdown yes so the first thing which we need to define is a loss function okay model compliation so to compile the model we need to define the loss function which loss function we want here and then we want optimizer okay and then after optimizer we want here metrics so what are these things a loss function it will measure how accurate the model is during the training and testing then okay actually the loss function minimize minimize the overall error during the training and once the error is minimized during the training then the testing error will be also minimized but that is not always the true because sometimes what happens if your model overpaid then the oral law skit minimized during the training but during the testing it get increased so here the generalization of model is very important that's where optimizer comes so this is how model is updated based on the data that's been the weights of our model applicants updated with the you know as we define the optimizer now let's go ahead and compile this model first so we can compile this with the model dot dot the compiled and then here we have optimizer is equal to Adam and then here we have a loss function there a loss is equal to a spazz categorical okay so there we have a sparse and categorical cross entropy okay and then finally here we have a matrix and inside this matrix we have accuracy okay perfect now let's go ahead and run this and once we run these Suites its of course it's it has compiled there now let's go ahead and train the model for a training a model it is really very simple as we have been doing into our SQL library there we have a mortal dot paid and then here we have X underscore train and then here we have y underscore train and then finally here we have a total number of epochs okay is equal to 10 so with this once we write this it will start suing a progress bar our during the training so the first time at the first epoch itself the accuracy has increased to 82 now do you know the epoch the epoch means at the first time the you know the weights get initialized randomly and when model moves to the second day pork then via back propagation it updates the model that's mean what it is doing at the ten times it is updating the models and then it is running on whole data and each epoch okay that's minify defining your a box is equal to the ten then that so in this model this this model is getting trained ten times on whole data that's mean the weights are getting updated ten times on the whole data now let's go ahead and finally evaluate the accuracy of the model how we can evaluate the accuracy to evaluate the accuracy and the tensorflow has inbuilt model dot he will wait but in this video version that is not working very precisely that's me let's say if I write here a test loss and then the test accuracy is equal to model dot evaluate okay so there it has X underscore test and then Y underscore test okay and then if we print here the test I Chrissy let's go ahead and see how much this tie Chrissy we will get here so this this is a kind of there is a problem I think perhaps that's why it is you know suing these random things although this will take us some time just around return 10 to 20 seconds and then it gets completed and then finally it will the source total accuracy on a test set okay now you see here the tests accuracy on test set has been shown at the end of this that says that the eighty eight point seven five percent of the accuracy Rd test and the total loss is zero point two five now you see here during the training our accuracy was a 91% and at the testing time accuracy is 88% that shows that the overfitting of our model so this is kind of a very simple neural network model just similarly just a single layer is there just a single hidden layer with the 128 neurons so we can expect that this much of the accuracy with this although if we use Union and other networks on this then we definitely we can get a better accuracy okay and on the github it it is claimed that with the CNN we can get around to 99% accuracy in some other lessons we will be also learning it with the CNN as well now let's go ahead and do the prediction with the now let's go ahead and do the prediction with the with the Escalon as well okay so what we can do here with from s killer dot matrix and then here we have import a crazy score okay so now we are we have here we have here accuracy sorry now we need to first get the wipe read as well so that we can get here Y prayer is equal to the wipe rate is equal to the model dot predict okay now you see here we have the two classes actually the predict and the predict classes and the predict probability so the predict will predict a set of the array that will be the continuous value but we need a predict classes so with the predict classes we can get actually what is the predicted class instead of a continuous value on yesterday doesn't that is expressed and then finally let's go ahead and bring it with the accuracy score that here we have y underscore test and then here we have y underscore bread so now you see we have got the accuracy of eighty eight point seven five percent which we have caught with thee with the model dot evaluate although I think there is some bug in this current version of the tensorflow that's why these things we are coming okay perfect now let's go ahead and make a prediction on adjust to some random the random test the image on us just a single image separately and then we will stop this lesson okay to do that what we can do you can just right there let's go ahead with the bread played with the model dot a simple predict and then finally we have here X underscore test now if we print here the bread so the prettiest kind of you know a continuous array that's why I had not done with the predict only that's why I had used here the predict classes and if you see there the wipe read the wipe read here is continuous its its categorical value actually that's been the classes okay so with this now let's go ahead one thing you see and the class has been predicted the first class has been predicted to nine and if you see here the first array the continuous value now you see here at the ninth one okay that's in the tenth class tenth number at the ninth index at the tenth index that's mean you know zero it starts from the zero that's been here nine so it says that at the 98th sent with the confidence of the 98% that it is the ninth okay what we can do now we can prayed here at the zero value now with this you can we see it very clearly okay so this is the maximum out you know the ninth place so that how we can do we can do with the org max here okay so here we have n P dot arcamax there's been the maximum argument at which place there so that's the Preds ero at the plate 0 you see maximum argument at 0th location and similarly we can bring this the maximum prediction at at the first location as well okay so at the first location the maximum is you know the argument - okay perfect so this is the way how we work with the tensorflow 2.0 this is all about in this lesson please don't forget to like this video and subscribe this channel so that you can get updates directly into your inbox in further lessons all week also covering more videos on a tensorflow and deep learning till then bye bye and keep learning

Up Next

Content-Based vs Collaborative Filtering for Recommendation Systems

@TensorFlow

89.1K views•2021-07-06

BitTorrent Protocol Explained: Piece Selection & Peer Choking

@StevenGordonAU

481 views•2013-02-22

HTTP Requests Explained: GET, POST, PUT, DELETE

@codecademy

103.1K views•2021-10-07

Enigma Machine Mechanics: WWII Encryption Explained

@JaredOwen

13.2M views•2021-12-11

Related Study Plans & Knowledge Roadmaps

Structured learning paths in Computer Science

View All Computer Science Topics

computer-science

Building BitTorrent: Go, P2P & Concurrency

01Go Fundamentals & Concurrency

02Networking Foundations & P2P Architecture

03Bencode Parsing & Torrent Metadata

+ 3 more learning modules

Explore Roadmap

computer-science

Actor Models (C++ Concurrency & Lock-Free)

01C++ Multi-Threading Foundations

02Thread Pools and Task Scheduling

03Atomics and Lock-Free Queue Design

+ 3 more learning modules

Explore Roadmap

computer-science

Coding HM Type Inference: Algorithm W & OCaml

01Introduction to Functional Programming & OCaml

02Abstract Syntax Trees & Language Interpreters

03Type Systems & Lambda Calculus

+ 2 more learning modules

Explore Roadmap

computer-science

Building OAuth 2.0: Node.js OIDC Server

01Web & Security Foundations

02Authentication vs. Authorization & JWTs

03The OAuth 2.0 Protocol & Grant Types

+ 3 more learning modules

Explore Roadmap