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

Descoperă cele mai bune repository-uri open source cu căutare AI.

ExploreazăCăutări recomandateAlternative open-sourceSoftware self-hostedBlogHartă site
ProiectServer MCPDespreCum realizăm clasamentulPresă
LegalConfidențialitateTermeni
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

38 repository-uri

Awesome GitHub RepositoriesNormalization Layers

Layers that normalize input activations to stabilize training and improve convergence.

Explore 38 awesome GitHub repositories matching artificial intelligence & ml · Normalization Layers. Refine with filters or upvote what's useful.

Awesome Normalization Layers GitHub Repositories

Găsește cele mai bune repo-uri cu AI.Vom căuta cele mai potrivite repository-uri folosind AI.
  • pytorch/pytorchAvatar pytorch

    pytorch/pytorch

    100,814Vezi pe GitHub↗

    PyTorch is a machine learning framework centered on a GPU-ready tensor library that supports multi-dimensional array operations across both CPU and accelerator hardware. It provides a foundational infrastructure for mathematical computation and dynamic neural network construction, utilizing a tape-based automatic differentiation system that allows for flexible, non-static graph execution. The framework is designed for deep integration with Python, enabling natural usage alongside standard scientific computing ecosystems. It distinguishes itself through a comprehensive distributed training sui

    Stabilizes training convergence by automatically inferring input shapes for standard normalization layers.

    Pythonautograddeep-learninggpu
    Vezi pe GitHub↗100,814
  • labmlai/annotated_deep_learning_paper_implementationsAvatar labmlai

    labmlai/annotated_deep_learning_paper_implementations

    66,981Vezi pe GitHub↗

    This project is a collection of deep learning research papers translated into annotated code. It serves as a resource for reproducing academic research, providing implementations of transformers, diffusion models, and reinforcement learning architectures. The library distinguishes itself by using a side-by-side annotation format that combines executable Python code with descriptive markdown notes. This approach provides a structured way to explain the logic of neural network papers alongside their PyTorch-based implementations. The codebase covers several major capability areas, including ge

    Integrates various data normalization strategies to stabilize network training and accelerate convergence.

    Pythonattentiondeep-learningdeep-learning-tutorial
    Vezi pe GitHub↗66,981
  • karpathy/llm.cAvatar karpathy

    karpathy/llm.c

    30,230Vezi pe GitHub↗

    This project is a low-dependency engine designed for training large language models using native C and CUDA. It provides a bare-metal environment for tensor computation, allowing for the execution of neural network operations directly on hardware accelerators without the overhead of high-level software abstractions. The framework distinguishes itself by implementing manual gradient backpropagation and custom hardware-specific kernels, providing granular control over memory mapping and computational precision. It supports distributed training across multiple graphics processors and compute nod

    Includes layer normalization components to stabilize activation scales and improve training convergence.

    Cuda
    Vezi pe GitHub↗30,230
  • d2l-ai/d2l-enAvatar d2l-ai

    d2l-ai/d2l-en

    29,001Vezi pe GitHub↗

    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 flex

    Stabilizes deep neural network training by applying layer normalization after residual connections.

    Pythonbookcomputer-visiondata-science
    Vezi pe GitHub↗29,001
  • fastai/fastaiAvatar fastai

    fastai/fastai

    27,862Vezi pe GitHub↗

    Fastai is a high-level deep learning library built on PyTorch that provides a unified interface for managing the entire machine learning lifecycle. It functions as a comprehensive training toolkit, abstracting hardware management and automating complex training loops to simplify the construction and execution of neural network models. The framework is distinguished by its notebook-centric development environment and a type-dispatching data pipeline that automatically applies transformations based on input data formats. It emphasizes transfer learning through discriminative layer-wise optimiza

    Standardizes layer inputs using batch or instance normalization to stabilize training and improve convergence.

    Jupyter Notebookcolabdeep-learningfastai
    Vezi pe GitHub↗27,862
  • huggingface/lerobotAvatar huggingface

    huggingface/lerobot

    21,687Vezi pe GitHub↗

    This project is a comprehensive research platform designed for the end-to-end lifecycle of robotic learning. It provides a modular framework for training neural network policies—specifically through imitation and reinforcement learning—and deploying them onto physical robotic hardware. By offering a unified interface for hardware abstraction, the platform decouples high-level control logic from the specific sensors and actuators of diverse robotic systems. The framework distinguishes itself through a standardized approach to data and policy management. It utilizes a consistent schema for reco

    Extracts normalization layers from trained model weights into external processor pipelines.

    Python
    Vezi pe GitHub↗21,687
  • mrdbourke/pytorch-deep-learningAvatar mrdbourke

    mrdbourke/pytorch-deep-learning

    17,195Vezi pe GitHub↗

    This project is a structured educational resource and training platform designed for mastering deep learning development. It provides a comprehensive curriculum focused on building, evaluating, and refining predictive models through hands-on coding exercises and standard industry workflows. The curriculum emphasizes practical implementation, guiding users through the construction of neural network architectures and the application of transfer learning to adapt pretrained models for custom tasks. It includes methodologies for tracking and comparing model experiment results, allowing for the sy

    Uses sequential containers to compose neural network architectures through modular layer stacking.

    Jupyter Notebookdeep-learningmachine-learningpytorch
    Vezi pe GitHub↗17,195
  • naklecha/llama3-from-scratchAvatar naklecha

    naklecha/llama3-from-scratch

    15,230Vezi pe GitHub↗

    This project is a manual reconstruction of the Llama 3 transformer architecture implemented as a PyTorch neural network. It serves as a reference for the internal mathematical structure and tensor flow of a transformer-based language model designed for next token prediction. The implementation focuses on building the model from scratch using basic matrix operations and tensor manipulations. It demonstrates the manual construction of core components, including rotary positional embeddings, multi-head self-attention, and root mean square normalization. The codebase covers the full inference pi

    Stabilizes numerical computations using root mean square normalization layers.

    Jupyter Notebook
    Vezi pe GitHub↗15,230
  • paddlepaddle/paddledetectionAvatar PaddlePaddle

    PaddlePaddle/PaddleDetection

    14,243Vezi pe GitHub↗

    PaddleDetection is an object detection framework designed for the end-to-end development, training, and deployment of computer vision models. It provides a comprehensive library of modular neural network architectures and pipelines that support object detection, instance segmentation, and multi-object tracking tasks. The project distinguishes itself through a configuration-driven approach that decouples model components like backbones and heads, allowing for the flexible assembly of custom vision workflows. It incorporates advanced techniques such as anchor-free detection logic, joint detecti

    Integrates group normalization layers to enhance training stability and model performance.

    Pythonblazefacedeepsortdetr
    Vezi pe GitHub↗14,243
  • soumith/ganhacksAvatar soumith

    soumith/ganhacks

    11,619Vezi pe GitHub↗

    This project is a PyTorch-based generative framework and implementation template for building Generative Adversarial Networks. It provides a collection of foundational toolkits and architectural patterns designed to synthesize high-quality artificial data while focusing on the stability of adversarial neural networks. The framework distinguishes itself through a specialized toolkit for conditional image generation, which integrates discrete labels and auxiliary classification into the training process. It utilizes specific mechanisms to guide the generative process toward target classes by co

    Implements batch and instance normalization layers to center and scale activations for improved convergence.

    Vezi pe GitHub↗11,619
  • karpathy/convnetjsAvatar karpathy

    karpathy/convnetjs

    11,171Vezi pe GitHub↗

    ConvNetJS is a JavaScript deep learning library and neural network training engine designed for client-side machine learning. It functions as a framework for building, training, and running convolutional neural networks directly within a web browser without the need for a backend server. The library specializes in image recognition and pattern analysis using convolutional and pooling layers. It enables the creation of models for classification and regression tasks, as well as the development of reinforcement learning agents that optimize behavior through trial and error in simulated environme

    Organizes neural networks as a series of stacked modules where data flows linearly from one layer to the next.

    JavaScript
    Vezi pe GitHub↗11,171
  • lyhue1991/eat_tensorflow2_in_30_daysAvatar lyhue1991

    lyhue1991/eat_tensorflow2_in_30_days

    9,933Vezi pe GitHub↗

    This project is a structured learning curriculum and technical reference for mastering deep learning with TensorFlow. It provides a comprehensive guide for building, training, and deploying neural networks, combining theoretical fundamentals with practical implementation examples. The repository distinguishes itself by covering the end-to-end machine learning workflow, from low-level tensor mathematics and linear algebra to the creation of complex model architectures. It includes specific guidance on developing data pipelines for diverse data types, such as images, text, and time-series seque

    Provides a sequential API for building neural networks by stacking modular data transformation layers.

    Pythontensorflowtensorflow-examplestensorflow-tutorial
    Vezi pe GitHub↗9,933
  • google-deepmind/sonnetAvatar google-deepmind

    google-deepmind/sonnet

    9,920Vezi pe GitHub↗

    Sonnet is a modular machine learning framework and TensorFlow neural network library designed for building composable deep learning architectures. It functions as a model orchestrator that manages parameters, state serialization, and graph exports during the training process. The framework provides a distributed training system to synchronize gradients and spread workloads across multiple GPUs or hardware devices. It enables the design of reusable research components through high-level abstractions and subclassing. The library covers neural network architecture design through sequential laye

    Supports grouping and connecting multiple neural network layers into a single sequential unit.

    Pythonartificial-intelligencedeep-learningmachine-learning
    Vezi pe GitHub↗9,920
  • jadore801120/attention-is-all-you-need-pytorchAvatar jadore801120

    jadore801120/attention-is-all-you-need-pytorch

    9,742Vezi pe GitHub↗

    This project is a Transformer machine translation model and attention-based neural network implemented using the PyTorch deep learning framework. It functions as a text-to-text translation tool designed to convert source sequences into target language text. The implementation focuses on neural machine translation, covering the development of sequence-to-sequence architectures. It includes the full pipeline for translation, from text sequence preprocessing and vocabulary creation to model training and text generation inference. The system incorporates standard transformer components such as a

    Incorporates layer normalization to stabilize training and improve convergence across transformer layers.

    Pythonattentionattention-is-all-you-needdeep-learning
    Vezi pe GitHub↗9,742
  • xlite-dev/leetcudaAvatar xlite-dev

    xlite-dev/LeetCUDA

    9,694Vezi pe GitHub↗

    LeetCUDA is a collection of high-performance GPU kernel libraries focusing on memory optimization, activation functions, and attention mechanisms. It serves as a reference library for CUDA kernel implementations, ranging from basic element-wise operations to complex neural network components, and provides Python bindings to integrate these kernels into deep learning workflows. The project is distinguished by its focus on low-level hardware optimizations. This includes the use of tensor cores for half-precision matrix multiplication, asynchronous data pipelining with double buffering, and shar

    Implements layer normalization to standardize vectors and stabilize training in neural networks.

    Cudacudacuda-12cuda-cpp
    Vezi pe GitHub↗9,694
  • morvanzhou/pytorch-tutorialAvatar MorvanZhou

    MorvanZhou/PyTorch-Tutorial

    8,458Vezi pe 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

    Uses normalization layers to standardize input activations, stabilizing training and preventing gradient saturation.

    Jupyter Notebookautoencoderbatchbatch-normalization
    Vezi pe GitHub↗8,458
  • tingsongyu/pytorch_tutorialAvatar TingsongYu

    TingsongYu/PyTorch_Tutorial

    8,018Vezi pe 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

    Implements normalization layers to standardize inputs to zero mean and unit variance for stable training.

    Python
    Vezi pe GitHub↗8,018
  • nvlabs/spadeAvatar NVlabs

    NVlabs/SPADE

    7,718Vezi pe GitHub↗

    SPADE is a semantic image synthesis framework and generative adversarial network designed to transform semantic label maps into photorealistic images. It uses a spatially-adaptive normalization model to modulate activations based on semantic maps, ensuring that spatial layouts and details are preserved throughout the synthesis process. The project enables the generation of diverse image variations from a single semantic layout by integrating variational autoencoders and latent vector style control. These mechanisms allow for the adjustment of visual appearances and textures while keeping the

    Replaces standard normalization with learned tensors that adjust feature maps based on local semantic class labels.

    Python
    Vezi pe GitHub↗7,718
  • liuliu/ccvAvatar liuliu

    liuliu/ccv

    7,223Vezi pe GitHub↗

    ccv is a computer vision library written in C designed for high-performance visual analysis. It serves as a framework for image classification, object detection, and the identification of faces, pedestrians, and vehicles. The library distinguishes itself through hardware-accelerated vision and deep learning inference optimizations. It utilizes a quantized tensor processor to transform floating-point data into eight-bit integers and implements integer-quantized attention mechanisms to reduce memory bandwidth and increase data throughput. The project covers a broad range of capabilities, inclu

    Executes layer normalization and root mean square normalization through specialized hardware kernels.

    C++
    Vezi pe GitHub↗7,223
  • afshinea/stanford-cs-230-deep-learningAvatar afshinea

    afshinea/stanford-cs-230-deep-learning

    7,028Vezi pe GitHub↗

    This repository collects illustrated single-page cheat sheets that compress the core topics of Stanford's CS 230 deep learning course into visual reference summaries. The collection covers convolutional neural networks, recurrent neural networks, and practical training techniques, pairing schematic diagrams with mathematical notation to bridge intuition and formal understanding. The cheat sheets are organized by subject area and link related concepts across topics, such as connecting vanishing gradients to LSTM gates, to reinforce the full deep learning workflow. Practical training advice on

    Covers batch normalization and layer normalization techniques for stabilizing deep network training.

    cheatsheetconvolutional-neural-networksdata-science
    Vezi pe GitHub↗7,028
Înapoi12Înainte
  1. Home
  2. Artificial Intelligence & ML
  3. Machine Learning
  4. Frameworks
  5. Model Construction
  6. Neural Network Layers
  7. Normalization Layers

Explorează sub-etichetele

  • Group NormalizationNormalization layers that group channels to stabilize training in deep neural networks. **Distinct from Normalization Layers:** Distinct from Batch Normalization: specifically implements group-based channel normalization.
  • Hybrid Normalization PlacementsNormalization strategies that combine pre- and post-layer normalization to balance stability and representation power. **Distinct from Normalization Layers:** Focuses on the relative placement and combination of norm layers rather than a single normalization type.
  • Learnable Scaling LayersNormalization layers that apply learnable scaling factors to residual block outputs for stable training. **Distinct from Normalization Layers:** Distinct from Normalization Layers: applies a learnable scale factor rather than standard statistical normalization.
  • Normalization InterceptionWrapping normalization layers with hooks to monitor and modify internal states. **Distinct from Normalization Layers:** Focuses on the interceptability of normalization layers for research, not the implementation of the normalization itself.
  • Normalization MigratorsUtilities for extracting normalization layers from model weights into external pipelines. **Distinct from Normalization Layers:** Distinct from general normalization layers: focuses on the migration of layers out of model weights.
  • Sandwich NormalizationsA specific normalization pattern that adds extra layers to all branch outputs to ensure stability. **Distinct from Normalization Layers:** A distinct topological arrangement of normalization layers compared to standard LayerNorm.
  • Sequential Layer Containers3 sub-tag-uriModules that group multiple neural network layers into a single reusable unit. **Distinct from Normalization Layers:** Focuses on the grouping of layers for modularity, distinct from normalization-specific layers.
  • Spatially-Aware LayersNeural network layers that adjust feature maps using local semantic class labels instead of global statistics. **Distinct from Normalization Layers:** Specializes standard normalization layers by making them aware of local semantic labels