Open-source alternatives to Chinese Text Classification Pytorch

This project is a TensorFlow-based supervised text categorizer designed for Chinese natural language processing. It utilizes a hybrid neural network architecture that combines convolutional and recurrent layers to map raw Chinese text to predefined categories. The system integrates convolutional neural networks for local feature extraction and recurrent neural networks for analyzing sequential dependencies. It employs character-level tokenization and word embeddings to represent text as numerical tensors. The implementation covers the end-to-end machine learning pipeline, including text prep

spaCy is a Python natural language processing framework designed for industrial-scale text processing. It converts raw text into structured data for machine learning pipelines through a combination of statistical language model trainers, transformer-based text processors, and syntactic dependency parsers. The project enables the integration of pretrained transformer architectures to perform complex linguistic analysis and multi-task learning. It also provides a specialized system for neural named entity recognition to identify and categorize key entities within text. The framework covers a b

Flair is a natural language processing framework for training and applying models for sequence labeling and text classification. It provides a system for generating word embeddings and identifying semantic entities within text. The framework includes a dedicated system for zero and few-shot learning, enabling text classification and entity extraction using minimal training examples by leveraging pre-trained knowledge. Its capabilities cover named entity recognition, sentiment analysis, and the training of specialized models using custom datasets. It also includes tooling for the visual highl

This is a Python machine learning library featuring a collection of core algorithms implemented from scratch to demonstrate foundational AI concepts. It provides a comprehensive toolkit for supervised learning, unsupervised learning, and neural network development. The project is distinguished by its custom implementation of a neural network framework, which includes multi-layer perceptrons with backpropagation, gradient descent, and weight regularization. It also includes a specialized anomaly detection toolkit that identifies outliers and rare events using Gaussian probability distributions

gpt-fast is a PyTorch transformer inference engine designed for text generation using a native tensor library implementation. It provides a runtime for executing large language models without the need for external C++ extensions. The project implements speculative decoding to accelerate generation by using a small draft model for token prediction and a larger model for verification. It further optimizes performance through a compiled prefill stage and a multi-GPU tensor parallelism library that shards linear layers across multiple graphics processing units. Memory efficiency is managed throu

MatchZoo is a deep learning framework designed for building, training, and evaluating neural networks that determine the relevance and similarity between pairs of textual inputs. It serves as a research platform for neural information retrieval, specifically supporting the development of models for document retrieval, question answering, and ranking tasks. The framework utilizes declarative architecture composition to define complex neural network structures. It includes automated hyper-parameter resolution to populate missing configuration parameters before model compilation and uses callbac

ML for Hackers is a machine learning educational resource and library designed for learning the fundamentals of algorithmic programming and data analysis. It provides a neural network framework and a collection of mathematical implementations for building and training predictive models. The project utilizes a modular architecture for stacking linear transformations and activation layers. It implements core deep learning components from scratch using multi-dimensional arrays for tensor algebra and operations. The framework covers a variety of algorithmic capabilities, including automatic diff

Orange3 is a visual data mining platform that provides an interactive canvas for building data analysis workflows without writing code. At its core, it offers a widget-based visual programming environment where users connect configurable components to perform data preprocessing, machine learning model training, statistical evaluation, and interactive visualization. The platform is built on NumPy-backed data tables with domain descriptors that define variable names, types, and roles, and includes a lazy SQL query proxy for working with database tables without loading all data into memory. The

This project is a PyTorch implementation of a research architecture designed for high-resolution representation learning. It serves as a computer vision framework focused on precise keypoint detection, human pose estimation, and semantic image segmentation. The implementation provides specialized tools for identifying anatomical landmarks on the human body and predicting facial keypoint coordinates to analyze orientation and alignment. It utilizes a system of multi-resolution parallel streams and repeated multi-scale fusion to maintain high-resolution representations throughout the network.

Pythia is a multimodal research framework and distributed training system designed for building, training, and evaluating large models that combine visual and linguistic data. It provides a modular environment for developing vision-language models, focusing on the integration of image and text inputs into shared feature representations. The framework utilizes a modular architecture that decouples model building blocks into interchangeable components, allowing for flexible configuration of vision and language modules. It includes a benchmark suite for executing reference models against standar

Lingua is a research framework for developing, training, and experimenting with large language model architectures and data strategies. It provides a lean codebase designed to facilitate the iteration of new model designs through a combination of distributed training orchestration and evaluation pipelines. The framework includes a distributed training orchestrator that generates submission scripts and manages configurations for launching tasks across compute clusters. It utilizes a configuration management system that allows model parameters to be overridden via data classes and command-line

Leaf is a machine learning framework and neural network architecture toolkit used for building, training, and deploying models. It functions as a hardware abstraction layer, mapping high-level computational graphs to low-level instructions across various CPU and GPU backends and operating systems. The system enables the design of flexible model structures through a modular architecture where reusable container layers encapsulate weights and mathematical operations. This allows for the composition of complex neural networks via nested components. The framework includes a data engineering pipe

This project is an educational implementation of a small-scale generative pre-trained transformer designed to teach the fundamentals of neural network architecture and training. It serves as a reference implementation and tutorial for constructing a text-generating neural network from scratch. The codebase demonstrates the mechanics of tokenization, self-attention, and the construction of a lightweight language model. It focuses on the step-by-step process of building a generative model to illustrate how large language models are constructed. The implementation covers transformer-based archi

HanLP is a natural language processing library and deep learning framework specifically optimized for the Chinese language, while also functioning as a multilingual text processor. It serves as a toolkit for performing linguistic analysis, semantic understanding, and script conversion. The project distinguishes itself through a dedicated focus on Chinese linguistic structures, including a specialized script converter for transforming text between Simplified Chinese, Traditional Chinese, and Pinyin. It further supports domain-specific model training to improve the recognition of professional t

Magika is an AI content type classifier and MIME type prediction engine that uses deep learning to identify file formats based on binary data. It analyzes byte sequences through a neural network to predict the content type of a file and provide associated confidence scores. The system features a foreign function interface that allows the core detection logic to be integrated across different programming languages. It includes a mechanism for configuring detection sensitivity and per-type thresholds to balance precision and recall. The project provides capabilities for bulk file analysis via

DeepPavlov is a conversational AI framework and deep learning NLP library designed for building end-to-end dialogue systems and chatbots. It functions as an NLP pipeline orchestrator that allows users to compose pre-trained models and text processing components into sequential data flows for complex linguistic tasks. The system is distinguished by its ability to act as a chatbot deployment server, exposing trained conversational models as web services via REST and Socket APIs. It utilizes JSON-based pipeline configurations and dynamic variable interpolation to decouple model logic from infras

This project is a TensorFlow implementation of a convolutional neural network designed for text classification. It functions as a deep learning text categorizer that assigns predefined labels to text documents by identifying and analyzing learned patterns within training sets. The model utilizes a sequence of embedding-layer vectorization, convolutional layers for feature extraction, and max-pooling downsampling to process text data. Final category probabilities are determined through a dense-layer classification system. The workflow covers the end-to-end machine learning lifecycle, includin

This project is a collection of TensorFlow machine learning examples providing reference implementations for various neural network paradigms. It covers supervised, unsupervised, reinforcement, and sequential learning models. The repository includes implementations for convolutional neural networks focused on image classification and ranking, as well as recurrent neural networks for time-series forecasting and sequence-to-sequence translation. It further provides examples of reinforcement learning agents trained via reward optimization and unsupervised learning techniques such as autoencoders

Flair is a transformer-based natural language processing framework used to build and train models for text classification and sequence tagging. It provides a specialized library for generating contextual text embeddings and performing linguistic analysis. The framework includes dedicated tools for named entity recognition, including the identification of specialized biomedical entities across multiple languages. It further supports entity linking to map identified text mentions to unique entries within general or biomedical knowledge bases. The project covers a broad range of language analys

This project is a PyTorch implementation of the YOLOv3 object detection architecture. It functions as a real-time object detector and computer vision framework designed to identify and locate multiple objects within images using bounding boxes and class labels. The system allows for both the use of pretrained weights for immediate image analysis and the training of custom models using datasets with bounding box annotations. It provides a programmatic interface to integrate detection capabilities directly into other software applications. The framework includes tools for model evaluation to m

Neural renderer is a differentiable rendering library for PyTorch that projects three-dimensional meshes into two-dimensional images while maintaining continuous mathematical gradients for backpropagation. The framework enables gradient-based inverse rendering, allowing optimization of input parameters such as camera pose, vertex positions, and texture maps by propagating pixel-level reconstruction errors backward to the source geometry. The architecture incorporates approximate rasterisation gradients that substitute discontinuous edge derivatives with heuristic approximations to facilitate

AllenNLP is a PyTorch-based research library and deep learning language toolkit designed for developing and training neural network architectures for linguistic tasks. It provides a distributed training system that coordinates data and gradients across multiple GPUs and a framework for integrating pretrained transformer architectures. The system distinguishes itself with a dedicated algorithmic bias mitigation tool used to identify and reduce bias in linguistic model predictions. It also includes model influence analysis to interpret predictions by calculating the influence of specific traini

xformers is a collection of specialized toolsets for fused GPU operators, sparse attention mechanisms, modular transformer components, and performance benchmarking. It provides a library of optimized and interoperable building blocks used to construct and experiment with transformer architectures. The project features a fused CUDA operator library that combines common layers into single GPU operations to increase throughput. It includes a sparse attention framework and memory-efficient attention kernels that utilize tiling strategies and structured sparsity patterns to reduce computational ov

fastText is a library and framework for word embedding generation, text vectorization, and supervised text classification. It provides tools to transform raw text into fixed-length vector representations and to train models that assign category labels to sentences or documents. The system utilizes subword-based vectorization and character n-gram embeddings, allowing it to generate meaningful vectors for words that were not present during training. To manage resource usage, it includes a quantized language model implementation that employs product quantization and dimensionality reduction to d

This is a PyTorch object detection framework that implements the Single Shot MultiBox Detector for identifying and localizing multiple objects within images and video. The project provides a neural network architecture designed for single-shot object detection, which predicts bounding boxes and class labels in one pass. The implementation includes a real-time object detector capable of processing live video streams to track and label objects across sequential frames. It also features a complete computer vision training pipeline for preparing image datasets and training model weights. The fra

This project is a PyTorch implementation of the Faster R-CNN architecture for object detection. It provides a framework for identifying multiple object classes and their corresponding bounding boxes within images using a deep learning system. The implementation includes a training pipeline for optimizing models on custom datasets and a utility for converting pretrained weights from external formats into a compatible structure for model initialization. The system covers a two-stage detection pipeline comprising a region proposal network and an ROI pooling layer. It incorporates multi-task los

Kaolin is a PyTorch 3D deep learning library providing a comprehensive suite of tools for 3D geometry processing, physics simulation, data visualization, and gradient-based rendering for computer vision. The library includes a differentiable 3D renderer and a geometry processing toolkit for converting and transforming 3D representations such as meshes and point clouds. It also features a 3D physics simulation engine to calculate physical interactions and collisions between three-dimensional objects and scenes. The toolkit provides utilities for 3D data visualization, including the creation o