awesome-repositories.com
Blog
awesome-repositories.com

Descubre los mejores repositorios open-source con nuestra búsqueda potenciada por IA.

ExplorarBúsquedas curadasAlternativas open-sourceSoftware autohospedableBlogMapa del sitio
ProyectoAcerca deCómo clasificamosPrensaServidor MCP
Aviso legalPrivacidadTérminos
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

46 repositorios

Awesome GitHub RepositoriesActivation Functions

Mathematical functions used to introduce non-linearity into neural network models.

Distinguishing note: Focuses on element-wise application of non-linear functions.

Explore 46 awesome GitHub repositories matching artificial intelligence & ml · Activation Functions. Refine with filters or upvote what's useful.

Awesome Activation Functions GitHub Repositories

Encuentra los mejores repositorios con IA.Buscaremos los repositorios que mejor coincidan usando IA.
  • exacity/deeplearningbook-chineseAvatar de exacity

    exacity/deeplearningbook-chinese

    37,285Ver en GitHub↗

    This project is a comprehensive Chinese translation of a technical deep learning textbook, providing an educational resource on the theory and implementation of neural networks. It functions as a collaborative technical translation project designed to make complex academic AI literature accessible to non-English speakers. The project utilizes a community-driven translation model that integrates external suggestions and pull requests to refine linguistic accuracy and reduce bias. It employs standardized terminology mapping to ensure a uniform vocabulary throughout the translated content. To i

    Covers the selection and use of non-linear activation functions for neural network hidden units.

    TeX
    Ver en GitHub↗37,285
  • tinygrad/tinygradAvatar de tinygrad

    tinygrad/tinygrad

    33,147Ver en GitHub↗

    Tinygrad is a deep learning framework and tensor computation engine designed for building and training neural networks. It functions as a hardware abstraction layer that manages device memory, command queues, and kernel dispatching across heterogeneous computing architectures. By utilizing a lazy-evaluation approach, the framework constructs computational graphs that defer execution until data is explicitly required, allowing it to process only the necessary operations for a given result. The project distinguishes itself through a just-in-time compilation layer that transforms abstract comput

    Applies non-linear activation functions like ReLU or sigmoid to tensor elements.

    Python
    Ver en GitHub↗33,147
  • d2l-ai/d2l-enAvatar de d2l-ai

    d2l-ai/d2l-en

    29,001Ver en 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

    Introduces non-linearity into neural network layers using functions like ReLU, sigmoid, or tanh.

    Pythonbookcomputer-visiondata-science
    Ver en GitHub↗29,001
  • accumulatemore/cvAvatar de AccumulateMore

    AccumulateMore/CV

    21,907Ver en 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,

    Applies non-linear mathematical operations to enable neural networks to learn complex representations.

    Jupyter Notebookagentagentsbook
    Ver en GitHub↗21,907
  • mnielsen/neural-networks-and-deep-learningAvatar de mnielsen

    mnielsen/neural-networks-and-deep-learning

    17,721Ver en GitHub↗

    This project is a comprehensive educational resource and curriculum designed to teach the mathematical foundations and practical implementation of neural networks. It provides a structured path for understanding how computers learn from data, covering core concepts such as gradient descent, backpropagation, and the biological inspiration behind artificial neurons. The platform distinguishes itself by combining theoretical proofs with hands-on implementation exercises. It demonstrates the universal approximation theorem through visual explanations and guides users in building various architect

    Configures diverse activation functions to introduce non-linearity and improve network performance.

    Python
    Ver en GitHub↗17,721
  • microsoft/cntkAvatar de Microsoft

    Microsoft/CNTK

    17,602Ver en GitHub↗

    CNTK is a deep learning toolkit used for the design, construction, and training of neural networks. It defines model architectures as computational graphs and optimizes network parameters using an automatic differentiation engine and stochastic gradient descent. The project emphasizes large scale model distribution, spreading training workloads across multiple hardware nodes and GPUs. It features specialized support for dynamic sequence handling, allowing filters to be convolved across both spatial and dynamic sequence axes to process data of variable lengths. The toolkit provides hardware-a

    Provides the Exponential Linear Unit (ELU) activation function with configurable saturation.

    C++
    Ver en GitHub↗17,602
  • state-spaces/mambaAvatar de state-spaces

    state-spaces/mamba

    17,215Ver en GitHub↗

    Mamba is a deep learning framework designed for building and training sequence models that process long-range data dependencies with linear-time computational efficiency. By utilizing selective state space modeling, the library enables the construction of neural network architectures that replace traditional attention mechanisms with high-performance state space operations. The framework distinguishes itself through the use of data-dependent state gating, which allows the model to dynamically filter information flow based on the input sequence. To ensure high throughput, it incorporates hardw

    Stabilizes training by applying specific activation functions to data-dependent state parameters.

    Python
    Ver en GitHub↗17,215
  • kindxiaoming/pykanAvatar de KindXiaoming

    KindXiaoming/pykan

    16,305Ver en GitHub↗

    pykan is a library for implementing Kolmogorov-Arnold Networks, replacing fixed node activation functions with learnable spline functions located on the network edges. It serves as an interpretable AI framework and symbolic regression tool designed to derive transparent mathematical rules from complex data. The project focuses on converting learned numerical functions into human-readable symbolic expressions through library matching and formula conversion. It utilizes additive-compositional topologies and learnable piecewise polynomial segments to approximate non-linear mappings. The framewo

    Replaces fixed node activations with learnable spline functions located on the network edges.

    Jupyter Notebook
    Ver en GitHub↗16,305
  • naklecha/llama3-from-scratchAvatar de naklecha

    naklecha/llama3-from-scratch

    15,230Ver en 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

    Implements gated linear units to introduce non-linearity within the feed-forward network.

    Jupyter Notebook
    Ver en GitHub↗15,230
  • alibaba/mnnAvatar de alibaba

    alibaba/MNN

    14,242Ver en GitHub↗

    MNN is a high-performance inference engine and framework designed for on-device machine learning. It provides a comprehensive environment for executing, optimizing, and deploying neural network models directly on mobile and resource-constrained edge devices. The framework distinguishes itself through a robust model optimization toolkit that supports quantization, compression, and structural graph manipulation to minimize memory footprint and maximize execution speed. It features a modular architecture that abstracts hardware-specific backends, allowing models to run efficiently across diverse

    Provides a library of non-linear activation functions to transform input data for neural network processing.

    C++armconvolutiondeep-learning
    Ver en GitHub↗14,242
  • shiqiyu/libfacedetectionAvatar de ShiqiYu

    ShiqiYu/libfacedetection

    12,749Ver en GitHub↗

    libfacedetection is a C++ face detection library and computer vision tool. It utilizes a neural network face detector to identify human faces in images and return bounding box coordinates. The library is designed for low latency and high throughput processing, enabling real-time face detection in image and video streams. It supports automated image analysis for identifying coordinates of human faces across large batches of photos and high-performance video processing.

    Reduces CPU cycle consumption by replacing complex activation functions with pre-calculated lookup tables.

    C++
    Ver en GitHub↗12,749
  • axolotl-ai-cloud/axolotlAvatar de axolotl-ai-cloud

    axolotl-ai-cloud/axolotl

    12,059Ver en GitHub↗

    Axolotl is a configuration-driven framework designed for the fine-tuning, evaluation, and quantization of large language models. It functions as a comprehensive orchestrator for distributed training, enabling users to manage complex workflows across multi-node and multi-GPU environments. By utilizing structured configuration files, the platform streamlines the setup of training parameters, dataset paths, and hardware distribution strategies. The project distinguishes itself through its support for diverse training methodologies, including full-parameter tuning, parameter-efficient adaptation,

    Implements activation functions using custom kernels to improve processing speed and reduce memory consumption.

    Pythonfine-tuningllm
    Ver en GitHub↗12,059
  • karpathy/convnetjsAvatar de karpathy

    karpathy/convnetjs

    11,171Ver en 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

    Applies mathematical functions to tensor outputs to allow the network to learn complex non-linear patterns.

    JavaScript
    Ver en GitHub↗11,171
  • cs231n/cs231n.github.ioAvatar de cs231n

    cs231n/cs231n.github.io

    10,923Ver en GitHub↗

    This project is a static educational website and comprehensive curriculum focused on computer vision and deep learning. It serves as a public repository of instructional materials, lecture notes, and technical guides specifically detailing convolutional neural networks and visual recognition. The site is developed using static-site generation to host course documentation and student project directories. It provides structured academic resources that guide learners through image classification, generative modeling, and the implementation of various neural network architectures. The curriculum

    Explains the application of mathematical functions like ReLU and Sigmoid to introduce non-linearity in neural networks.

    Jupyter Notebook
    Ver en GitHub↗10,923
  • lyhue1991/eat_tensorflow2_in_30_daysAvatar de lyhue1991

    lyhue1991/eat_tensorflow2_in_30_days

    9,933Ver en 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

    Implements various non-linear activation functions to control signal flow within neural networks.

    Pythontensorflowtensorflow-examplestensorflow-tutorial
    Ver en GitHub↗9,933
  • xlite-dev/leetcudaAvatar de xlite-dev

    xlite-dev/LeetCUDA

    9,694Ver en 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

    Ships a suite of optimized CUDA kernels for element-wise activation functions like ReLU, GELU, and Sigmoid.

    Cudacudacuda-12cuda-cpp
    Ver en GitHub↗9,694
  • wongkinyiu/yolov9Avatar de WongKinYiu

    WongKinYiu/yolov9

    9,534Ver en GitHub↗

    YOLOv9 is a real-time computer vision framework and deep learning model designed for image classification, object detection, and instance segmentation. It functions as both a vision model and a trainer, allowing for the optimization of neural network weights on custom datasets using single or multiple GPUs. The framework utilizes programmable gradient information to perform high-speed identification and location of multiple objects within images and video streams. It extends beyond bounding box detection to provide instance segmentation and panoptic segmentation, which labels every pixel in a

    Provides flexible, polynomial-based activation functions to optimize the flow of data and gradients.

    Pythonyolov9
    Ver en GitHub↗9,534
  • morvanzhou/pytorch-tutorialAvatar de MorvanZhou

    MorvanZhou/PyTorch-Tutorial

    8,458Ver en 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

    Teaches the use of mathematical functions to introduce non-linearity into neural network models.

    Jupyter Notebookautoencoderbatchbatch-normalization
    Ver en GitHub↗8,458
  • tingsongyu/pytorch_tutorialAvatar de TingsongYu

    TingsongYu/PyTorch_Tutorial

    8,018Ver en 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 non-linear activation functions to transform linear signals and produce probability distributions.

    Python
    Ver en GitHub↗8,018
  • liuliu/ccvAvatar de liuliu

    liuliu/ccv

    7,223Ver en 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

    Computes the Swish activation function with configurable beta parameters across diverse hardware architectures.

    C++
    Ver en GitHub↗7,223
Ant.123Siguiente
  1. Home
  2. Artificial Intelligence & ML
  3. Activation Functions

Explorar subetiquetas

  • B-Spline ActivationsActivation functions using piecewise polynomial B-splines to provide flexible, learnable non-linearities. **Distinct from Activation Functions:** Specifically implements learnable B-splines on edges rather than standard element-wise non-linear functions
  • Edge-Based Activations1 sub-etiquetaTrainable activation functions placed on network edges rather than inside neurons. **Distinct from Activation Functions:** Distinct from standard activation functions which are applied to node outputs; these are learnable splines located on edges.
  • Gated Linear Units4 sub-etiquetasActivation mechanisms that use a gating tensor to control the flow of information through a linear layer. **Distinct from Activation Functions:** Distinct from general Activation Functions by using a gating mechanism rather than a simple element-wise non-linearity.
  • HardShrink ActivationsImplementations of the hard-shrinkage non-linear function for tensor data. **Distinct from Activation Functions:** Specific non-linear activation function, whereas Activation Functions is the general category.
  • HardSwish ActivationsImplementations of the hard-swish non-linear function for tensor data. **Distinct from Activation Functions:** Specific non-linear activation function, whereas Activation Functions is the general category.
  • Heavy-Tail ActivationsActivation functions applied to state parameters to stabilize training at high learning rates. **Distinct from Activation Functions:** Focuses on heavy-tail activation functions for state parameter stability, distinct from general non-linear activation functions.
  • Lookup Table OptimizationsReplacing complex mathematical activation functions with pre-calculated tables to reduce CPU cycles. **Distinct from Activation Functions:** Focuses on the optimization technique of using tables to approximate activation functions, rather than the general mathematical definition of the function.
  • ReLU VariantsNon-linear activation functions including ReLU, Leaky ReLU, and ELU applied element-wise. **Distinct from Activation Functions:** Distinct from Activation Functions: specifically covers ReLU and its variants, not all activation functions.
  • SELU ActivationsScaled Exponential Linear Unit functions used for self-normalizing neural networks. **Distinct from Activation Functions:** Specifies the SELU function specifically, rather than general non-linear activation functions.
  • Stochastic ActivationsNeuron activation functions that incorporate probabilistic distributions to introduce randomness. **Distinct from Activation Functions:** Adds the specific property of stochasticity to the general category of non-linear activation functions.
  • Swish Activations1 sub-etiquetaImplementations of the swish non-linear function for tensor data. **Distinct from Activation Functions:** Specific non-linear activation function, whereas Activation Functions is the general category.