awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
d2l-ai avatar

d2l-ai/d2l-en

0
View on GitHub↗
D2L.ai↗

D2l En

This project is an educational platform and research toolkit designed to teach deep learning through a combination of mathematical theory, visual diagrams, and executable code. It provides a comprehensive environment for building, training, and evaluating neural networks, grounding complex concepts in interactive computational notebooks that allow for hands-on experimentation.

The framework distinguishes itself by interleaving theoretical foundations—including linear algebra, calculus, and probability—with practical implementations across multiple industry-standard libraries. It supports flexible model development through modular layer composition, deferred parameter initialization, and symbolic graph hybridization, which balances the ease of imperative coding with the performance benefits of compiled execution.

The project covers a broad capability surface, including computer vision, natural language processing, recommender systems, and reinforcement learning. It provides infrastructure for data pipeline management, gradient-based optimization, and distributed training across multiple hardware accelerators. Users can leverage built-in utilities for hyperparameter tuning, model regularization, and performance monitoring to diagnose and refine their architectures.

The documentation is delivered as a series of interactive notebooks that can be executed locally or on remote cloud infrastructure, providing a standardized interface for deep learning research and experimentation.

Features

  • Automatic Differentiation Engines - Tracks mathematical operations during forward passes to compute gradients automatically for parameter optimization.
  • Automatic Differentiation Frameworks - Computes gradients of complex functions automatically to support parameter optimization without manual derivation.
  • Model Training - Executes deep learning model training using minibatch stochastic gradient descent and cross-entropy loss.
  • Reinforcement Learning - Provides a comprehensive framework for training agents to maximize cumulative rewards through sequential decision-making.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
29,001 stars·5,076 forks·Python·62 views
  • Deep Learning Notebooks - Provides interactive notebooks combining mathematical theory and executable code for deep learning experimentation.
  • Deep Learning Curricula - Offers an interactive educational platform that combines mathematical theory with executable code for learning deep learning.
  • Deep Learning Education - Explains complex machine learning theories through a combination of mathematical notation, visual diagrams, and interactive code examples.
  • Deep Learning Platforms - Provides a comprehensive platform for learning and implementing deep learning models from scratch.
  • Language Model Fine-Tuning - Adapts large-scale transformer models to downstream tasks through fine-tuning at sequence and token levels.
  • Mathematical Foundations - Provides theoretical background on linear algebra, calculus, and probability to help practitioners understand deep learning mechanics.
  • Neural Network Toolkits - Provides a research toolkit for building, training, and evaluating neural networks.
  • Neural Training Pipelines - Executes configurable training loops with learning rate scheduling, weight decay, and performance monitoring.
  • Stochastic Gradient Descent - Updates model parameters using single randomly sampled data points to reduce computational cost.
  • Interactive Notebook Environments - Delivers interactive deep learning experimentation through executable computational notebooks combining theory and code.
  • Deep Learning Frameworks - Provides a framework for mastering deep learning mechanics through interactive experimentation.
  • Exposition Integrations - Combines theoretical mathematical explanations with diagrams and code to provide a comprehensive understanding of deep learning principles.
  • Backpropagation - Computes gradients of model parameters by traversing networks in reverse and applying the chain rule.
  • Object Detection - Identifies and localizes multiple objects within images using bounding boxes and region-based classification.
  • End-to-End Training Pipelines - Optimizes machine learning pipelines jointly from raw data to eliminate manual feature engineering.
  • Generative Adversarial Networks - Constructs deep convolutional models using transposed convolutions for image generation and standard convolutions for discrimination.
  • Gradient Computation - Provides automatic differentiation tools to calculate function gradients for model training and optimization.
  • Language Model Architectures - Implements recurrent neural network architectures to predict subsequent tokens based on vocabulary and sequence context.
  • Loss Functions - Minimizes cross-entropy loss between predicted probability distributions and actual labels.
  • Tensor Computing Libraries - Detects and selects available hardware accelerators to distribute and accelerate tensor operations.
  • Model Fine-Tuning - Adapts pretrained Transformer architectures to specific downstream tasks by modifying output layers and training on domain-specific data.
  • Lazy Parameter Initializations - Defers model parameter allocation until the first data pass to enable flexible architecture definition.
  • Markov Decision Process Solvers - Formulates and solves Markov Decision Processes to optimize long-term utility in sequential decision-making environments.
  • Masked Language Modeling - Implements input token masking to train models on predicting original content from context.
  • Model Pretraining Frameworks - Composes pretraining architectures by integrating encoders, masked modeling, and relationship prediction components.
  • Language Model Pretraining - Provides self-supervised pretraining methods to learn semantic word and subword representations from large text corpora.
  • Neural Network Composition - Encapsulates neural network components into reusable blocks that track parameters and gradients.
  • Neural Network Implementations - Supports building and training deep learning models from scratch using low-level mathematical operations.
  • Training Execution Loops - Orchestrates iterative training loops including gradient calculation and parameter updates across epochs.
  • Optimization Algorithms - Provides standard optimization algorithms like minibatch stochastic gradient descent to update model parameters during training.
  • Recommendation Models - Provides architectures for training recommendation models using latent factor embeddings and gradient-based optimization.
  • Reinforcement Learning Value Estimators - Implements dynamic programming algorithms to compute optimal value functions for sequential decision-making tasks.
  • Supervised Learning - Trains predictive models on labeled datasets to perform classification and regression tasks.
  • Pixel Class Predictors - D2L extends detection models with alignment layers and convolutional networks to identify the precise pixel-level boundaries of objects within an image.
  • Multimodal Explanations - Combines mathematical theory, visual diagrams, and executable code to provide a comprehensive understanding of complex machine learning concepts.
  • Distributed Parameter Synchronisation - Coordinates gradient aggregation across multiple devices to decouple communication from model optimization.
  • Hybrid Execution Modes - Combines imperative code execution with compiled symbolic graphs for balanced flexibility and performance.
  • Computer Vision Toolkits - Provides modular toolkits for implementing advanced architectures like object detection and semantic segmentation.
  • Contextual Embedding Generators - Generates contextual embeddings that adapt token representations based on surrounding text usage.
  • Convolutional Neural Network Architectures - Chains convolutional, pooling, and fully connected layers to process spatial data for classification tasks.
  • Custom Training Loops - Provides generic training functions for orchestrating custom gradient-based optimization loops.
  • Data Augmentation Pipelines - Chains multiple image transformation methods into sequences for robust data augmentation during training.
  • Dropout Regularization - Randomly zeroes out neural network units during training to prevent overfitting.
  • Encoder-Decoder Architectures - Constructs sequence-to-sequence models by chaining encoders and decoders to process and generate tokens.
  • Fully Convolutional Architectures - Constructs pixel-level classification models by combining feature extraction with spatial restoration layers.
  • Learning Rate Schedulers - Adjusts learning rates dynamically using decay strategies to balance convergence speed and stability.
  • Minibatch Optimizers - Updates model parameters iteratively by calculating gradients on small, randomly sampled subsets of data.
  • Model Training Frameworks - Optimizes sequence model parameters using automated training loops with gradient clipping and hardware acceleration.
  • Sequence-to-Sequence Tasks - Trains sequence-to-sequence models using recurrent neural networks with teacher forcing for sequence mapping tasks.
  • Hyperparameter Optimization - Runs multiple training trials in parallel and prunes underperforming configurations to optimize hyperparameters.
  • Multilayer Perceptrons - Builds deep neural networks by stacking fully connected layers and applying activation functions.
  • Forward Propagation Engines - Calculates and stores intermediate variables and outputs during the forward pass of neural networks.
  • Naive Bayes Classifiers - Implements probabilistic classification models based on conditional independence assumptions.
  • Natural Language Processing - Processes sequential text data for tasks like sentiment analysis and machine translation.
  • Word Embeddings - Trains word embeddings by predicting context words from center words or vice versa.
  • Skip-Gram Model Architectures - Implements skip-gram training architectures to learn word representations via context prediction.
  • Neural Architecture Definitions - Provides base classes for implementing model architectures, including forward passes, loss calculation, and training steps.
  • Neural Network Modules - Provides base classes for encoders, decoders, and attention mechanisms to standardize model structure and training flow.
  • Next Sentence Prediction - Generates sentence pairs to teach models sequence relationship prediction through binary classification.
  • Gradient Descent Algorithms - Updates model parameters by iteratively taking steps in the direction opposite to the gradient to minimize loss.
  • Loss Function Calculators - Computes negative log-likelihood of predicted probabilities against true labels to measure performance.
  • Recommendation Architectures - Implements neural collaborative filtering by combining matrix factorization and multilayer perceptrons.
  • Gated Recurrent Units - Implements gated recurrent units to selectively retain or discard information in sequential data.
  • Semantic Segmentation - Predicts the class of every individual pixel in an image by training a network to output a label map of the same spatial dimensions.
  • Sequential Data Models - Models environmental states and temporal dependencies to optimize decision-making in sequential control systems.
  • Transformer Architectures - Constructs encoder-decoder models using stacked self-attention layers, residual connections, and layer normalization.
  • Transposed Convolutions - Broadcasts input elements using kernels to produce larger output tensors, reversing standard convolution dimensionality reduction.
  • Vision Transformers - Implements transformer blocks using pre-normalization and activation functions to process image patch sequences for classification.
  • Weight Decays - Penalizes large weight values using norm-based decay to constrain model complexity.
  • Deep Learning Resources - Interactive book integrating math and code for deep learning.
  • Machine Learning and Deep Learning - Interactive textbook for deep learning with code examples.
  • Learning and Reference - Interactive deep learning book.
  • Tutorials - Listed in the “Tutorials” section of the The Incredible Pytorch awesome list.
  • Educational Content Interleaving - Combines mathematical explanations with executable code blocks to demonstrate how theoretical concepts are applied in practice.
  • Optimization Algorithms - D2L calculates Hessian matrix eigenvalues to classify zero-gradient positions as local minima, local maxima, or saddle points in high-dimensional spaces.
  • Activation Functions - Introduces non-linearity into neural network layers using functions like ReLU, sigmoid, or tanh.
  • Anchor Box Generators - Generates grids of candidate bounding boxes with varying scales and aspect ratios for object detection.
  • Anchor Box Labelers - Assigns class labels and coordinate offsets to anchor boxes to prepare training data.
  • Ground Truth Assignment Algorithms - Maps ground-truth objects to anchor boxes using intersection over union thresholds.
  • Attention Scoring Functions - Calculates attention scores by scaling the dot product of queries and keys before softmax normalization.
  • Batch Normalization - Stabilizes training and accelerates convergence by normalizing layer inputs using batch statistics.
  • Image Augmentation - Provides random image transformations like cropping and flipping to improve model robustness during training.
  • Segmentation Dataset Loaders - Downloads and prepares image segmentation datasets by mapping pixel-level labels to semantic classes.
  • Spatial Dimension Controllers - Controls spatial expansion by configuring padding and strides in transposed convolutional operations.
  • Custom Neural Network Layers - Implements custom forward propagation logic to integrate specialized operations into sequential model architectures.
  • Dense Connectivity Patterns - Concatenates input and output of multiple convolution layers along the channel dimension to create dense feature connectivity.
  • Detection Filtering - Applies non-maximum suppression to remove redundant bounding box detections.
  • Distributed Training - Coordinates gradient aggregation across multiple physical servers to prevent bandwidth bottlenecks and maintain consistent model updates.
  • Data-Parallel Training - Distributes neural network training across multiple devices by splitting data batches and computing gradients in parallel.
  • Dynamic Parameter Initialization - Defers parameter allocation until the first data pass to allow flexible network definition.
  • Expert Imitation Learning - Trains models to replicate expert agent actions through behavioral cloning.
  • Feature Map Upscalers - Increases feature map spatial resolution using transposed convolutional layers with bilinear interpolation.
  • Feature Interaction Models - Automatically learns high-order feature interactions using factorization machines and multilayer perceptrons.
  • Gaussian Processes - Predicts continuous outputs by modeling latent functions with Gaussian processes.
  • Gradient Clipping Utilities - Limits the magnitude of gradients during training to prevent numerical instability and divergence.
  • Linear Regression - Represents relationships between features and targets using weighted sums and bias terms in matrix-vector notation.
  • Neural Network Layers - Constructs models using pre-built layers that automatically infer input dimensions to simplify architecture definition.
  • Convolutional Block Composers - Groups multiple convolutional layers followed by pooling to create modular, deep network architectures.
  • Gradient Flow Stabilizers - Selects activation functions that maintain gradient flow to prevent vanishing gradients in deep networks.
  • Interaction Matrix Factorizers - Decomposes interaction matrices into latent user and item vectors to predict missing ratings.
  • Model Selection and Validation - Facilitates model selection by evaluating configurations on dedicated validation sets to prevent test set leakage.
  • Model Training Pipelines - Applies trained models to real-world datasets through preprocessing, cross-validation, and performance evaluation.
  • Bidirectional Recurrent Neural Networks - Supports bidirectional recurrent neural networks to capture context from both past and future sequence elements.
  • Natural Language Processing Datasets - Downloads and parses large-scale text inference corpora into structured premise and hypothesis pairs.
  • Object Detection Datasets - Retrieves and verifies remote image datasets containing class labels and bounding box coordinates.
  • Model Performance Visualizations - Generates comprehensive visualizations of model performance metrics, including loss curves and attention heatmaps.
  • Model Training Optimizers - Adjusts learning rates per coordinate using moving averages of squared gradients to maintain stable training progress.
  • Adversarial Training Procedures - Optimizes generator and discriminator networks simultaneously to stabilize adversarial training.
  • Cross-Validation Utilities - Provides cross-validation utilities to iteratively train and validate models for robust performance estimation.
  • Multi-Head Attention Mechanisms - Processes input sequences through multiple parallel attention heads to capture diverse relationships and dependencies.
  • Natural Language Classification - Classifies sentence relationships to determine logical sequence coherence using classification tokens.
  • Pretrained Embedding Loaders - Initializes model token representations by loading external word vector datasets.
  • Global Embedding Trainers - Trains global word embeddings by minimizing loss over co-occurrence statistics across a corpus.
  • Likelihood Minimizers - Converts product-based likelihood functions into sum-based loss functions for stable numerical optimization.
  • Optimal Action Estimation - Estimates state-action values by sampling visited states without requiring prior knowledge of environment dynamics.
  • Adaptive Learning Rate Optimizers - Adjusts learning rates for individual parameters based on historical squared gradients.
  • Acceleration Methods - Uses historical gradient information to smooth out oscillations and speed up convergence during parameter optimization.
  • Performance Evaluation Tools - Calculates classification accuracy metrics by comparing model predictions against ground truth labels.
  • Accuracy Calculators - Computes classification accuracy by comparing predicted labels to ground truth.
  • Recommendation List Generators - Generates ranked lists of relevant items tailored to individual user preferences.
  • Sequential Interaction Processors - Analyzes ordered sequences of user actions to model evolving preferences over time.
  • Region-based Detection - Extracts candidate image areas using selective search and processes them through convolutional networks for object classification and bounding box refinement.
  • Region Proposal Generators - Uses trainable sub-networks to predict object locations directly from feature maps.
  • Regularization Techniques - Implements various regularization techniques to prevent overfitting in high-capacity neural networks.
  • Negative - Generates unobserved user-item pairs during training to enable pairwise ranking optimization and improve model discrimination.
  • Sequence Learning Models - Handles variable-length data sequences like language translations by maintaining context across multiple time steps.
  • Sequential Learning - Models temporal dependencies in input sequences by maintaining internal states through recurrent connections.
  • Tensor Broadcasting - Expands tensors of different shapes to a common dimension for compatible operations.
  • Text Classification - Processes text inputs through classification layers to assign discrete labels for sentiment or linguistic tasks.
  • Text Generation - Generates text by conditioning language models on prefixes and iteratively feeding outputs back into the model.
  • Token Prediction - Generates sequence predictions by conditioning trained models on initial prefix strings.
  • Text Tokenizers - Segments raw text into tokens and appends end-of-sequence markers for model input.
  • Training Stability Techniques - Applies initialization and numerical stability methods to prevent gradient divergence during deep network optimization.
  • User Interaction Predictors - Estimates future user behavior through rating prediction, item ranking, and sequence-aware modeling.
  • Vector Similarity Search - Queries semantic similarity between words using cosine similarity in trained embedding spaces.
  • Vocabulary Management - Implements byte-pair encoding to extract subword units and manage fixed-size vocabularies for efficient text segmentation.
  • Weight Regularization - Restricts weight magnitude using penalty terms to favor simpler parameter values.
  • Multi-Label Classifiers - Categorizes complex items by applying multiple non-exclusive tags to a single input.
  • Data Pipelines - Encapsulates data loading and preprocessing logic into modular classes that provide standardized interfaces for training and validation data loaders.
  • Model Serialization - Saves model structures and parameters to disk in language-agnostic formats for cross-environment deployment.
  • Sentiment Classifiers - Categorizes text sequences into sentiment labels using bidirectional neural networks to identify emotional polarity.
  • Softmax Regression - Maps input data to discrete categories using a softmax output layer and cross-entropy loss.
  • Color Adjustment Utilities - Modifies brightness, contrast, saturation, and hue to increase dataset diversity and improve model generalization.
  • Probability Distributions - Models and visualizes probability mass, density, and cumulative distribution functions for common statistical distributions.
  • Probability Smoothing Utilities - Applies pseudo-counts to probability estimates to prevent zero-probability issues for rare features.
  • Sequence Likelihood Estimators - Evaluates sequence probabilities by decomposing joint densities into products of conditional probabilities.
  • Attention Mechanisms - Computes attention scores by passing concatenated queries and keys through a single-layer network.
  • Bounding Box Coordinate Predictors - Transforms anchor box coordinates using model-predicted offsets to generate final object locations.
  • Classification Models - Initializes weight matrices and bias vectors to map input features to a specific number of output classes for prediction.
  • Pooling Replacements - Uses global average pooling instead of dense layers to reduce parameter counts while maintaining classification performance.
  • Convolutional Neural Networks - Processes image patches identically regardless of spatial location to ensure consistent feature detection across inputs.
  • Cross-Correlation Operators - Computes feature maps by sliding a kernel window across an input tensor to perform elementwise products and sums.
  • Sequence Padding Utilities - Standardizes input lengths by appending special tokens and generating weight masks for uniform batch processing.
  • Custom Model Training - Iterates over training data to update parameters of specific model components.
  • Data Preprocessing Utilities - Converts raw external data into standardized tensor formats for machine learning pipelines.
  • Dataset Preparation Utilities - Processes pairs of text sequences into tokenized input formats with segment identifiers and length truncation.
  • Distribution Shift Mitigation - Corrects for covariate shift by reweighing source data based on target feature distributions.
  • Vocabulary Builders - Generates unified token mappings from training data for consistent numerical representation.
  • Exploration Strategies - Balances exploration and exploitation using epsilon-greedy strategies to optimize cumulative rewards.
  • Hardware Acceleration - Provides utilities for offloading neural network computations to hardware accelerators like GPUs.
  • Click-Through Rate Predictors - Estimates interaction probability using factorization machines for click-through rate prediction.
  • Learning Rate Warmup Strategies - Applies learning rate warmup strategies to stabilize optimization during the early phases of training.
  • In-Context Learning Engines - Enables task execution by conditioning model output on prompts and examples without requiring parameter updates.
  • Autoregressive Decoding Strategies - Ensures sequence generation depends only on previously produced tokens by applying masks to decoder self-attention.
  • Bounding Box Metrics - Calculates the Jaccard index to quantify spatial overlap between bounding boxes.
  • Convolution Layers - Combines input tensors with learnable kernel weights and bias parameters to extract spatial features.
  • Grouped - Splits input channels into independent groups to reduce computational cost and parameter count.
  • Normalization Layers - Stabilizes deep neural network training by applying layer normalization after residual connections.
  • Recurrent Layers - Supports stacking multiple recurrent units to process sequential data through successive hidden state layers.
  • Recurrent Model Definitions - Constructs gated recurrent neural network layers using high-level APIs for optimized training.
  • GPU Training Accelerators - Distributes tensor operations and neural network execution across hardware accelerators to achieve significant performance improvements.
  • Mathematical Training Objectives - Updates model parameters using gradient-based optimization to minimize objective functions.
  • Initialization Stabilizers - Initializes network weights to specific scales to ensure matrix products remain stable and prevent exploding gradients.
  • Recurrent Stability Mechanisms - Uses gated memory cells to maintain internal states across time steps, preventing vanishing gradients in recurrent models.
  • Tensor Operations - Executes element-wise mathematical operations and binary operators on tensors.
  • Model Loading - Exports trained model weights to external files and imports them into pre-defined model architectures to resume state or perform inference.
  • Early Stopping Monitors - Terminates training when validation error stops improving to prevent overfitting.
  • Beam Search Decoders - Implements beam search decoding to maintain multiple candidate sequences for efficient and accurate output generation.
  • Sequence-to-Sequence Translation Tasks - Implements encoder-decoder architectures and search algorithms for sequence-to-sequence mapping and translation tasks.
  • Memory Optimization Techniques - Optimizes memory usage through in-place operations and graph compilation to minimize redundant allocations.
  • Model Compilation Optimizers - Provides tools for compiling imperative model code into optimized symbolic graphs to improve execution performance on hardware accelerators.
  • Training Batchifiers - Organizes center, context, and noise words into padded minibatches with masks and labels for iterative training.
  • Model Performance Analysis - Diagnoses model performance issues by comparing training and validation error rates.
  • Minibatch Training Utilities - Groups training data into minibatches to improve computational efficiency and reduce gradient variance.
  • Negative Sampling Techniques - Reduces computational complexity by replacing full probability calculations with binary classification against noise words.
  • K-Fold Cross-Validation - Implements k-fold cross-validation to assess model generalization and tune hyperparameters.
  • Model Weight Management - Downloads and initializes model weights and vocabulary files to establish a starting point for training.
  • Multi-Fidelity Optimization - Accelerates hyperparameter search by evaluating model performance on cheap-to-compute proxies.
  • Multi-GPU Training Utilities - Splits data batches across multiple accelerators and synchronizes gradients to scale training throughput.
  • Analogy Solvers - Solves word analogies by performing vector arithmetic on embedding representations.
  • Subsampling Utilities - Discards common words from text corpora based on relative frequency to improve training speed and focus.
  • Subword Representation Models - Constructs word representations using subword character n-grams to handle rare or out-of-vocabulary terms.
  • Neural Network Architectures - Configures network stages by defining depth, channel width, and group parameters for efficient model designs.
  • Neural Style Transfer - Synthesizes images by combining content and style features extracted from pretrained networks.
  • Parameter Servers - Distributes model weights across a cluster of machines using key-value stores to enable large-scale distributed training.
  • Posterior Inference - Calculates updated function distributions after observing data to enable predictive modeling.
  • Numerical Stability Utilities - Calculates cross-entropy loss directly from logits using the LogSumExp trick to prevent numerical overflow.
  • Rating Matrix Reconstructors - Reconstructs sparse rating matrices using autoencoders to predict missing values.
  • Personalized Rankers - Optimizes item ranking based on relative user preferences rather than absolute ratings.
  • Reinforcement Learning Optimizers - Extracts optimal action policies from converged value functions to determine best moves.
  • Residual Networks - Adds shortcut connections between layers to simplify the learning of identity mappings.
  • Sentiment Analysis with CNNs - Implements convolutional neural networks with multiple kernel widths and pooling for text sentiment classification.
  • Sequence Decoders - Integrates attention mechanisms into sequence-to-sequence models by dynamically updating context variables.
  • Tensor Indexing - Enables reading and updating specific tensor elements or ranges using standard indexing.
  • Tensor Reductions - Aggregates tensor elements along axes using summation or averaging to reduce dimensionality.
  • Sequence Representation Builders - Provides utilities for preparing text sequences with special tokens and segment identifiers for bidirectional encoder processing.
  • Training Progress Monitors - Provides live graphical dashboards for monitoring real-time training metrics.
  • Uncertainty Estimation - Quantifies uncertainty by calculating the entropy of discrete or continuous random variables.
  • Unsupervised Learning - Identifies underlying structures in unlabeled data using techniques like clustering and generative modeling.
  • User Feedback Collection - Converts interaction records into explicit rating matrices or implicit feedback dictionaries for machine learning.
  • Weight Initialization - Applies weight initialization strategies like Xavier initialization to layers before training.
  • Text Ingestion Services - Downloads and parses raw text files into structured sequences and labels for machine learning.
  • Categorical Encodings - Converts discrete class labels into one-hot encoded vectors for mathematical operations on non-ordinal categories.
  • Categorical Encoders - Maps raw categorical values to numerical indices and applies frequency thresholds for machine learning pipelines.
  • Data Preprocessing Utilities - Standardizes numerical features and encodes categorical variables for tabular data processing.
  • Training Data Pipelines - Integrates image normalization and augmentation into automated data loading workflows for training.
  • Array and Tensor Manipulation - Provides indexing, slicing, and broadcasting for high-dimensional data manipulation.
  • Tensor Transformations - Converts processed numerical datasets into framework-specific tensor formats for model computation.
  • Missing Data Imputation - Handles incomplete records by imputing missing values with statistical estimates or converting gaps into indicator features.
  • Model Persistence Formats - Saves and loads tensors and trained model parameters to disk to enable checkpointing and model reuse.
  • Personalized Ranking Optimizers - Implements Bayesian pairwise optimization to prioritize user preferences in recommendation ranking.
  • Text Pair Inference Models - Aligns tokens between text sequences using attention mechanisms to predict logical relationships like entailment or contradiction.
  • Recursive Prediction Generators - Provides recursive multistep forecasting by feeding model-generated predictions back into the input window.
  • Span Extraction Utilities - Identifies start and end positions of answers within passages by predicting token-level probabilities.
  • Minibatch Iterators - Groups processed features and labels into minibatches to facilitate efficient training and testing loops.
  • Batch Vectorization - Performs matrix-based operations on minibatches to accelerate training and improve computational efficiency.
  • Dynamic Control Flow - Computes gradients for dynamic control flows by tracing execution paths during the forward pass.
  • Matrix-Vector Products - Performs fundamental linear algebra transformations including matrix-vector and matrix-matrix multiplications.
  • Conditional Probability Operations - Updates event likelihoods based on new evidence using conditional probability operations.
  • Divergence Measures - Quantifies statistical distance between probability distributions using divergence measures like Kullback–Leibler.
  • Joint Probability Calculators - Computes the likelihood of multiple random variables occurring simultaneously to analyze data dependencies.
  • Softmax Normalization - Applies softmax normalization to convert raw model outputs into valid probability distributions.
  • Random Variables - Generates random values sampled from statistical distributions for simulation and modeling.
  • Expected Value Calculators - Computes weighted averages of random variables to determine the central tendency of probabilistic outcomes.
  • Statistical Estimation - Estimates model parameters from observed data samples to assess statistical convergence.
  • Modular Architectures - Constructs neural networks by iterating over block configurations to create diverse network families from templates.
  • Metric and Performance Monitors - Monitors loss and accuracy metrics in real-time during model training and validation.
  • Tabular Data Loaders - Imports structured data from comma-separated files into manipulatable formats for analysis and training.

    • Star history

    Star history chart for d2l-ai/d2l-enStar history chart for d2l-ai/d2l-en

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Projects sharing features with D2l En

    These projects share indexed features with D2l En. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • accumulatemore/cvAccumulateMore avatar

      AccumulateMore/CV

      21,907View on GitHub↗

      This project is a comprehensive deep learning framework and educational platform designed for constructing, training, and evaluating neural network architectures. It provides a modular environment for building models through tensor operations and automatic differentiation, supporting a wide range of tasks from image classification and object detection to sequential data processing. Beyond its core technical capabilities, the project distinguishes itself by integrating professional career development resources directly into its learning ecosystem. It offers structured guidance, resume reviews,

      Jupyter Notebookagentagentsbook
      View on GitHub↗21,907
    • tingsongyu/pytorch_tutorialTingsongYu avatar

      TingsongYu/PyTorch_Tutorial

      8,018View on GitHub↗

      This project is a comprehensive collection of educational examples and reference implementations for building vision and language models using PyTorch. It serves as a deep learning tutorial covering the end-to-end process of developing neural networks, from initial architecture definition to final production deployment. The repository provides detailed guides on implementing a wide range of domain-specific models, including convolutional neural networks for object detection and segmentation, as well as transformer and recurrent architectures for natural language processing. It emphasizes gene

      Python
      View on GitHub↗8,018
    • yunjey/pytorch-tutorialyunjey avatar

      yunjey/pytorch-tutorial

      32,385View on GitHub↗

      This project is a collection of educational examples and code for implementing deep learning architectures using the PyTorch framework. It serves as a tutorial and implementation guide for building various neural network architectures for machine learning tasks. The project provides practical implementations for computer vision, including image classification and neural style transfer, as well as natural language processing examples for building sequence models and language predictors. It also covers generative models using adversarial and variational networks to synthesize or transform visua

      Pythondeep-learningneural-networkspytorch
      View on GitHub↗32,385
    • morvanzhou/pytorch-tutorialMorvanZhou avatar

      MorvanZhou/PyTorch-Tutorial

      8,458View on GitHub↗

      This project is a collection of PyTorch learning resources and educational guides designed to teach the construction and training of neural networks. It serves as a comprehensive deep learning tutorial covering various model architectures and practical implementation strategies. The resources provide specific guidance on implementing computer vision tasks, such as image classification and synthetic imagery generation, as well as reinforcement learning agents using value networks and experience replay. It also covers sequential data modeling through recurrent networks and generative modeling u

      Jupyter Notebookautoencoderbatchbatch-normalization
      View on GitHub↗8,458
    Compare all 30 related projects→

    Frequently asked questions

    What does d2l-ai/d2l-en do?

    This project is an educational platform and research toolkit designed to teach deep learning through a combination of mathematical theory, visual diagrams, and executable code. It provides a comprehensive environment for building, training, and evaluating neural networks, grounding complex concepts in interactive computational notebooks that allow for hands-on experimentation.

    What are the main features of d2l-ai/d2l-en?

    The main features of d2l-ai/d2l-en are: Automatic Differentiation Engines, Automatic Differentiation Frameworks, Model Training, Reinforcement Learning, Deep Learning Notebooks, Deep Learning Curricula, Deep Learning Education, Deep Learning Platforms.

    Which projects share features with d2l-ai/d2l-en?

    Projects with overlapping indexed features include: accumulatemore/cv — This project is a comprehensive deep learning framework and educational platform designed for constructing, training,… tingsongyu/pytorch_tutorial — This project is a comprehensive collection of educational examples and reference implementations for building vision… yunjey/pytorch-tutorial — This project is a collection of educational examples and code for implementing deep learning architectures using the… morvanzhou/pytorch-tutorial — This project is a collection of PyTorch learning resources and educational guides designed to teach the construction… mnielsen/neural-networks-and-deep-learning — This project is a comprehensive educational resource and curriculum designed to teach the mathematical foundations and… mrdbourke/pytorch-deep-learning — This project is a structured educational resource and training platform designed for mastering deep learning…