Shared model definitions for text, vision, audio and multimodal AI models

Machine learning models come in many architectures, and research teams often publish their own code. Transformers collects those model definitions in one library with a common interface. You can load a model from the Hugging Face Hub and use it without learning a new codebase each time.

The quickest way in is the Pipeline class. You name a task, such as text generation or speech recognition, and a model. It downloads the model, prepares the input, runs it and returns the result. For more control, the library exposes model internals and includes a training API for PyTorch models.

The README says these model definitions are meant to be the agreed reference across the ecosystem. Training frameworks (Axolotl, Unsloth, DeepSpeed, FSDP, PyTorch-Lightning), inference engines (vLLM, SGLang, TGI) and libraries like llama.cpp and mlx reuse them. It says it is not a modular toolbox of neural net building blocks, and for generic training loops it points to Accelerate.

Read more on interesting repos · GitHub

Small zero-shot model that pulls any entity types out of text, CPU-friendly

Named entity recognition (NER) means finding things like people, dates, organizations and places in text. Classic NER models only know the labels they were trained on. GLiNER lets you pass in the labels you want at prediction time, such as person or credit card number, and returns the matching spans.

You load a pretrained model from Hugging Face, give it text and a list of labels, and call predict_entities. The models are small enough to run on a CPU. The README says they compete with larger LLMs like ChatGPT and UniNER on NER, and it offers torch.compile, FP16 and INT8 quantization, and ONNX export for speed.

Besides the original uni-encoder design, the repo has a bi-encoder for very large label sets, a joint entity and relation extraction model, a decoder variant that generates entity types, and a streaming model for incremental NER. You can fine-tune them on your own data, and a Ray Serve layer handles production serving.

Read more on interesting repos · GitHub

vLLM patches and Docker setups to run Qwen3.8-27B fast on one 24 GB GPU

Large Qwen models are hard to serve well on a card you can buy in a shop. Stock vLLM leaves speed and context length unused on a 24 GB GPU. HyperQwen packages the fixes as Docker Compose profiles, so you can start a server without assembling the pieces yourself.

It has three parts. A series of patches against a pinned vLLM 0.31.0. A pipeline that requantizes the model, including its output heads, and builds a 40k-token draft vocabulary calibrated on the model's own output. And speculative decoding that can draft tokens straight from the prompt, which is why answers that quote the input run much faster.

There are two modes, and one GPU runs one at a time. Single mode suits one or a few people chatting. Batch mode suits API backends with many concurrent requests. The README reports 127 tok/s single-stream, about 1,035 tok/s aggregate at 64 concurrent, and 381 tok/s when the answer quotes the prompt. These numbers come from one RTX 3090 capped at 250 W. Other cards are mostly community reports, and the README lists open faults on some.

Read more on interesting repos · GitHub

Open models that give a probability for every answer option, and think only when unsure

Most LLMs answer by writing text, so you have to parse it and guess how sure the model was. StartLux-Decision takes a state (text, JSON or images) and a set of typed questions. It returns a probability for every option of every question.

There are two variants. Instant models answer in a single forward pass. AutoThink models also start with one pass, but if the top probability is below a gate (0.6 by default) they write a short reasoning trace and read the answer again. So they spend tokens only on hard cases.

This repository holds the inference engine and an HTTP server with a System One compatible API at /v1/systemone. It runs on vLLM, and the models also ship as GGUF and MLX files for llama.cpp and Apple hardware. The authors report the 27B Instant model ranks first on the Decision Index 0.3.2 leaderboard; that is their own account, and the technical report has the full evaluation.

Read more on interesting repos · GitHub

Trying an open-source project usually means cloning a repo, setting up Python or Node, installing dependencies and running commands in the right order. Pinokio wraps that into scripts you run from a graphical app, so you click instead of typing.

A Pinokio script is written in JSON and can run any command, download files and execute them. Think of it as a terminal with a UI. You can write your own scripts or install them from a Discover page of reviewed scripts.

Isolation is the main design idea. Apps live under ~/pinokio/api, and binaries from the built-in package managers (Conda, Homebrew, Pip, NPM) go under ~/pinokio/bin. A venv attribute keeps Python dependencies inside each app's folder. Scripts can still run anything, so read them before you run them.

Read more on interesting repos · GitHub

Most people who work with large language models only use them or fine-tune an existing one. Libraries like transformers, trl and peft hide the inner workings behind a few lines of code. MiniMind goes the other way. It implements the core model and training algorithms directly in plain PyTorch, so you can read how each stage works.

The model is small: about 64M parameters, with a 6,400-token vocabulary. The author says one epoch of the SFT stage takes about 2 hours on a single NVIDIA 3090, at a GPU rental cost of about 3 yuan. You download a small dataset, run a pretraining script, then a fine-tuning script, and end up with a chatbot you trained yourself.

The repo goes well beyond basic training. It includes LoRA, DPO, PPO, GRPO and CISPO, tool calling, agentic reinforcement learning, distillation and a mixture-of-experts variant. The architecture follows Qwen3, so the weights work with transformers, llama.cpp, vllm and ollama. The README is mainly in Chinese, with an English version linked.

Read more on interesting repos · GitHub

Claudish is a parody project. It turns short plain sentences like "Only owners can merge." into the overwrought, AI-assistant-sounding prose the README calls Claudish. It can also translate that style back into plain English.

It uses two ProgramAsWeights (PAW) functions, one for each direction. You load each by its ID with paw.function. The programs download once and then run on your machine. A small translate.py script wraps them for the command line.

The repo also includes the written specs behind both functions, so you can copy them into your own PAW program or adapt them for another model. It is inspired by gvzdv/claudish-to-english. It is unofficial and not affiliated with Anthropic.

Read more on interesting repos · GitHub

Needle is a foundation model for small devices. The whole model is one 8-29 MB file. It gives up general chat ability so it can do a narrow set of jobs well: choose which of your app's functions to call, fill in the arguments, and return typed data from unstructured text.

You declare your tools as Python functions or as a JSON file. The model reads the user's request and returns one JSON object with function calls, its reasoning and a confidence score. A grammar built from your schemas constrains each token, so the output always parses. If no tool fits the request, you get an empty list instead of a guess.

The README says it beats models 10x its size on mobile tool calls and matches models 2-3x larger on extraction. Those figures are the authors' own benchmarks. The package also includes Whistle, a small speech-to-text model that shares the same runtime, so audio can go in and tool calls come out. You can fine-tune Needle on your own tools, either locally or on the authors' hosted platform.

Read more on interesting repos · GitHub

Big language models normally need a GPU large enough to hold all their weights. AirLLM avoids that. It splits a downloaded model into layers saved on disk, then loads one layer onto the GPU, runs it, frees it, and moves to the next. GPU memory depends on the size of a single layer, not the whole model.

You use it much like the Hugging Face transformers library. You pass a model ID to AutoModel.from_pretrained, tokenize your text, and call generate. The README says this works without quantization, distillation or pruning. An optional 4-bit or 8-bit compression only shrinks the weights read from disk, which the README says can speed things up by up to 3x.

The trade-off is disk and time. The split copy of the model needs a lot of disk space, and reading layers from disk at every step is slower than keeping the model in memory. The README gives no speed figures for the largest models, so it looks better suited to experiments than to serving many users.

Read more on interesting repos · GitHub

Running a language model is one thing. Giving yourself or a team a comfortable place to talk to it is another. Open WebUI is that place: a web app you host yourself, which connects to Ollama for local models and to any OpenAI-compatible service such as LMStudio, Groq, Mistral, OpenRouter or vLLM. You can mix providers in the same install, and the README says it can run entirely offline.

Around the chat window it adds the things people usually bolt on later. You can load documents and ask questions about them (retrieval-augmented generation, or RAG, with a choice of nine vector databases), search the web, generate images, talk by voice, and keep notes, calendars and scheduled prompts. Administrators set up users, groups and permissions, and can sign people in through LDAP, OAuth or SSO.

It is also extensible. You can add Filters, Actions, Pipes, Tools and Skills, connect MCP or OpenAPI tool servers, and wrap a base model with instructions, tools and knowledge to make a specialised agent. Compared with a bare Ollama command line or a single-provider chat app, the draw is that it is a full multi-user platform. The feature list is long, so expect more to configure than in a minimal chat UI.

Read more on interesting repos · GitHub

Vane is a web app you run yourself that answers questions the way hosted AI search products do. You type a question, it searches the web, and a language model writes an answer with links to the sources it used. The repo's topics mention Perplexica, which appears to be the project's earlier name.

Under the hood it uses SearxNG, an open-source meta-search engine, to gather results from several search engines. The model then reads those results and writes the reply. You pick the model: a local one through Ollama or Lemonade, or a hosted one from OpenAI, Claude, Gemini or Groq. The Docker image bundles SearxNG, so there is little to set up.

The main difference from a hosted AI search product is control. Your history is saved locally, you choose the model, and you can add Vane to your browser's search bar or call it from your own code through an API.

Read more on interesting repos · GitHub

Running AI locally usually means stitching together separate projects such as Ollama or llama.cpp, Open WebUI, n8n and ComfyUI, then writing Docker configs so they talk to each other. ODS (Osmantic Deployment System) does that setup for you. One installer detects your hardware, picks a model, generates credentials and starts the services.

It is a Docker-based stack. A llama-server handles inference, Open WebUI gives you a chat page, and a dashboard lets you manage models, services and GPU status. Voice, agents, workflows, document search and image generation run alongside. Cloud API modes (OpenAI, Anthropic, Together) are optional if you have no GPU.

The README compares it to Ollama and llama.cpp, Open WebUI, AnythingLLM and n8n's self-hosted AI starter kit. Each of those covers one slice. ODS aims to be the whole server around them. It is labelled a V3 pre-release that installs the current main branch, which is not a signed release, so expect rough edges.

Read more on interesting repos · GitHub

Classic OCR tools read one page at a time and often lose layout, tables and reading order. Unlimited-OCR is a model that looks at page images and writes out the parsed document, and it is built to handle long inputs such as many pages in a single request.

You give it an image or a list of page images with a short prompt like 'document parsing.' or 'Multi page parsing.' For a single image there are two modes, 'gundam' (cropped, 640 px) and 'base' (1024 px). Multi-page and PDF input uses base mode only. A PDF is first turned into page images with PyMuPDF, then parsed together.

The README says it aims to push DeepSeek-OCR one step further and credits DeepSeek-OCR, DeepSeek-OCR-2 and PaddleOCR. It ships with a no-repeat n-gram setting to stop the model looping on long outputs. The code is MIT licensed and the weights are on Hugging Face and ModelScope.

Read more on interesting repos · GitHub

Osaurus is a layer that sits between you and any AI model. The model does the thinking. Osaurus keeps the rest on your Mac: agent prompts, memory, tools and identity. You can swap models without losing any of it.

Each agent has its own prompts, memory and theme. Give an agent a working folder and it gets file, search and git tools. Turn on the sandbox and it can run shell commands inside an isolated Linux VM (macOS 26+) or a Seatbelt sandbox on older systems. The model writes a todo list, works through it and ends with a summary.

It runs local models through MLX and can also connect to cloud providers. The README says it exposes OpenAI-, Anthropic- and Ollama-compatible APIs and works as an MCP server. A built-in Orchestrator can hand tasks to other agents or models as subagents. Compared with Electron-based chat apps, it is written natively in Swift.

Read more on interesting repos · GitHub

LingBot-Map reconstructs 3D scenes from a stream of images or a video. It is a feed-forward model: each new frame goes through the network and updates the 3D result directly, instead of running a slow optimization over the whole sequence afterward.

To keep long sequences stable, it uses a Geometric Context Transformer. The README describes three kinds of memory: an anchor context for grounding coordinates, a pose-reference window for dense local cues, and a trajectory memory that corrects drift over time. Attention uses a paged KV cache through FlashInfer, with a PyTorch SDPA fallback.

The authors report about 20 FPS at 518x378 resolution on sequences over 10,000 frames, and say it beats other streaming and optimization-based methods on their benchmarks. There are limits: it was trained with video RoPE on 320 views, so longer inputs need a keyframe interval or windowed mode, and very long runs without state resetting can see pose collapse.

Read more on interesting repos · GitHub

Forecasting usually means training a model for each dataset. TimesFM is already trained on a large body of time series, so you hand it your history and ask for the next steps. It is a decoder-only model, described in an ICML 2024 paper.

You pass in arrays of past values and get back a point forecast plus nine quantiles (0.1 to 0.9) for the horizon you choose. Version 3.0 forecasts several variates at once and accepts covariates, which are extra signals known only for the past, or for the future too. There are PyTorch and Apple-silicon MLX backends.

The README says 3.0 ranks first on three forecasting benchmarks (fev-bench, TIME, GIFT-Eval), which is the authors' own claim. Licensing matters: the code is Apache-2.0 and weights up to 2.5 are too, but 3.0 weights are for non-commercial, non-production use only. Commercial use goes through Google Cloud services such as BigQuery ML.

Read more on interesting repos · GitHub

This repo is a hub, not a code library. It describes the GLM-5 series of large language models from Z.ai and points to the weights on Hugging Face and ModelScope. The models are aimed at coding and long-horizon agent work, where a model has to plan, call tools and keep going for many steps.

The flagship models are mixture-of-experts: 744B total parameters with 40B active per token. GLM-5.3-Flash is a smaller 320B model with 18B active, and uses a mix of sparse and linear attention to cut the cost of long contexts. GLM-5.2 supports a 1M-token context. Each model comes in FP8 and BF16 precision, so you can trade memory for fidelity.

The README gives benchmark numbers, but they come from the authors, so treat them as claims to check. The practical content is the serving list (SGLang, vLLM, Transformers, KTransformers, Unsloth, Ascend NPU) and the fine-tuning options (slime, ms-swift). You can also skip the self-hosting and use the models through the Z.ai API.

Read more on interesting repos · GitHub

Robots and self-driving cars need lots of realistic data and a way to predict what happens next. Cosmos offers world models for this. They can describe what they see, or generate new video, sound and actions from text, images and other inputs.

Cosmos 3 is one omnimodal model family with two surfaces. The Reasoner takes text and vision and outputs text, for understanding and planning. The Generator takes text, vision, sound and action and outputs vision, sound and action, for simulation, future prediction, synthetic data and policy learning.

This repo is where you explore, run and evaluate the models. Training lives in the separate Cosmos Framework repo, data curation in Cosmos Curator, and output evaluation in Cosmos Evaluator. The README says outputs can show artifacts like object morphing or implausible physics, and safety-critical uses need extra validation.

Read more on interesting repos · GitHub

Odysseus is an AI workspace you run on your own machine or server. Instead of separate apps for chatting with a model, writing documents, reading email and keeping a calendar, you get them in one web interface with AI built into each part.

You start it with Docker Compose and open it in the browser at localhost:7000. It can use models you host locally or hosted APIs. Agents can use tools, MCP, files, a shell, skills and memory. A Cookbook section suggests models that fit your hardware, then downloads and serves them.

The README does not compare it to other projects by name. The difference is breadth: IMAP/SMTP email, CalDAV calendar sync, a writing-focused editor and blind model comparison all sit beside the chat. The README warns it has powerful local tools, so keep authentication on if it is reachable over a network.

Read more on interesting repos · GitHub

TRIBE v2 is a brain encoding model. You give it a video, an audio clip or a piece of text, and it predicts how a person's brain would respond, as fMRI activity over time. This lets neuroscientists test ideas in software before, or instead of, running a scanner.

It combines existing text, audio and video models into one Transformer. The Transformer maps their features onto the cortical surface, using the fsaverage5 mesh of about 20,000 vertices. Predictions are for an average subject and are shifted 5 seconds back to account for the delay in blood-flow response. Text input is turned into speech and transcribed, so words get timings.

The README does not compare it to other tools. It does ship pretrained weights on Hugging Face, a Colab demo, a paper, and the code to train from scratch on studies such as Algonauts2025 and Lahner2024. The license is CC BY-NC 4.0, so commercial use is not allowed.

Read more on interesting repos · GitHub

Financial candlestick charts are noisy, and general time-series models often handle them poorly. Kronos is built for this one kind of data. It treats sequences of K-lines (open, high, low, close, volume) like a language a model can learn to continue.

It works in two stages. A tokenizer first turns the continuous price numbers into hierarchical discrete tokens. Then an autoregressive Transformer, trained on those tokens, predicts what comes next. The README contrasts it with general-purpose time-series foundation models.

Four model sizes are listed, from 4.1M to 499.2M parameters. Mini, small and base are on Hugging Face. Large is not released. The repo also has a fine-tuning pipeline, shown with Chinese A-share data via Qlib, plus a simple backtest. The authors say it is a demo, not a production trading system.

Read more on interesting repos · GitHub

AI Edge Gallery is a showcase app from Google. You install it on a phone, download an open model, and run it locally. The README says inference happens on the device, so no internet is needed once the model is downloaded.

The app is built on Google AI Edge and LiteRT, a lightweight runtime for running models efficiently on mobile hardware. Models are found and downloaded through Hugging Face, and you can also load your own. Each feature is a tile: chat, image questions, audio transcription, a prompt workspace, and a few experiments built on small FunctionGemma finetunes.

Unlike a cloud chatbot, your prompts and images stay on the device. It is also a testing bench: it has a benchmark feature that shows how each model runs on your phone. The README calls it an experimental beta, so expect rough edges.

Read more on interesting repos · GitHub