awesome-repositories.com
ब्लॉग
MCP
awesome-repositories.com

AI-संचालित खोज के साथ बेहतरीन ओपन-सोर्स रिपॉजिटरी खोजें।

एक्सप्लोर करेंक्यूरेटेड खोजेंओपन-सोर्स विकल्पसेल्फ-होस्टेड सॉफ्टवेयरब्लॉगसाइटमैप
प्रोजेक्टMCP सर्वरहमारे बारे मेंहम रैंकिंग कैसे करते हैंप्रेस
कानूनीगोपनीयताशर्तें
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

38 रिपॉजिटरी

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

AI के साथ बेहतरीन रिपॉजिटरी खोजें।हम AI का उपयोग करके सबसे सटीक रिपॉजिटरी खोजेंगे।
  • pytorch/pytorchpytorch का अवतार

    pytorch/pytorch

    100,814GitHub पर देखें↗

    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
    GitHub पर देखें↗100,814
  • labmlai/annotated_deep_learning_paper_implementationslabmlai का अवतार

    labmlai/annotated_deep_learning_paper_implementations

    66,981GitHub पर देखें↗

    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
    GitHub पर देखें↗66,981
  • karpathy/llm.ckarpathy का अवतार

    karpathy/llm.c

    30,230GitHub पर देखें↗

    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
    GitHub पर देखें↗30,230
  • d2l-ai/d2l-end2l-ai का अवतार

    d2l-ai/d2l-en

    29,001GitHub पर देखें↗

    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
    GitHub पर देखें↗29,001
  • fastai/fastaifastai का अवतार

    fastai/fastai

    27,862GitHub पर देखें↗

    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
    GitHub पर देखें↗27,862
  • huggingface/lerobothuggingface का अवतार

    huggingface/lerobot

    21,687GitHub पर देखें↗

    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
    GitHub पर देखें↗21,687
  • mrdbourke/pytorch-deep-learningmrdbourke का अवतार

    mrdbourke/pytorch-deep-learning

    17,195GitHub पर देखें↗

    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
    GitHub पर देखें↗17,195
  • naklecha/llama3-from-scratchnaklecha का अवतार

    naklecha/llama3-from-scratch

    15,230GitHub पर देखें↗

    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
    GitHub पर देखें↗15,230
  • paddlepaddle/paddledetectionPaddlePaddle का अवतार

    PaddlePaddle/PaddleDetection

    14,243GitHub पर देखें↗

    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
    GitHub पर देखें↗14,243
  • soumith/ganhackssoumith का अवतार

    soumith/ganhacks

    11,619GitHub पर देखें↗

    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.

    GitHub पर देखें↗11,619
  • karpathy/convnetjskarpathy का अवतार

    karpathy/convnetjs

    11,171GitHub पर देखें↗

    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
    GitHub पर देखें↗11,171
  • lyhue1991/eat_tensorflow2_in_30_dayslyhue1991 का अवतार

    lyhue1991/eat_tensorflow2_in_30_days

    9,933GitHub पर देखें↗

    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
    GitHub पर देखें↗9,933
  • google-deepmind/sonnetgoogle-deepmind का अवतार

    google-deepmind/sonnet

    9,920GitHub पर देखें↗

    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
    GitHub पर देखें↗9,920
  • jadore801120/attention-is-all-you-need-pytorchjadore801120 का अवतार

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

    9,742GitHub पर देखें↗

    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
    GitHub पर देखें↗9,742
  • xlite-dev/leetcudaxlite-dev का अवतार

    xlite-dev/LeetCUDA

    9,694GitHub पर देखें↗

    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
    GitHub पर देखें↗9,694
  • morvanzhou/pytorch-tutorialMorvanZhou का अवतार

    MorvanZhou/PyTorch-Tutorial

    8,458GitHub पर देखें↗

    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
    GitHub पर देखें↗8,458
  • tingsongyu/pytorch_tutorialTingsongYu का अवतार

    TingsongYu/PyTorch_Tutorial

    8,018GitHub पर देखें↗

    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
    GitHub पर देखें↗8,018
  • nvlabs/spadeNVlabs का अवतार

    NVlabs/SPADE

    7,718GitHub पर देखें↗

    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
    GitHub पर देखें↗7,718
  • liuliu/ccvliuliu का अवतार

    liuliu/ccv

    7,223GitHub पर देखें↗

    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++
    GitHub पर देखें↗7,223
  • afshinea/stanford-cs-230-deep-learningafshinea का अवतार

    afshinea/stanford-cs-230-deep-learning

    7,028GitHub पर देखें↗

    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
    GitHub पर देखें↗7,028
पिछला12अगला
  1. Home
  2. Artificial Intelligence & ML
  3. Machine Learning
  4. Frameworks
  5. Model Construction
  6. Neural Network Layers
  7. Normalization Layers

सब-टैग एक्सप्लोर करें

  • 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 सब-टैग्सModules 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