世界のAIモデルディレクトリ

sentence-transformers/all-MiniLM-L6-v2

all-MiniLM-L6-v2 This is a sentence-transformers model: It maps sentences & paragraphs to a 384 dimensional dense vector space and can be used for tasks like clustering or semantic search. Usage (Sentence-Transformers) Using this model becomes easy when you have sentence-transformers installed: Then you can use the model like this: Usage (HuggingFace Transformers) Without sentence-transformers, you can use the model like this: First, you pass your input through the transformer model, then you have to apply the right pooling-operation on-top of the contextualized word embeddings. The project aims to train sentence embedding models on very large sentence level datasets using a self-supervised contrastive learning objective. We used the pretrained nreimers/MiniLM-L6-H384-uncased model and fine-tuned in on a 1B sentence pairs dataset. We use a contrastive learning objective: given a sentence from the pair, the model should predict which out of a set of randomly sampled other sentences, was actually paired with it in our dataset. We developed this model during the Community week using JAX/Flax for NLP & CV, organized by Hugging Face. We developed this model as part of the project: Train the Best Sentence Embedding Model Ever with 1B Training Pairs. We benefited from efficient hardware infrastructure to run the project: 7 TPUs v3-8, as well as intervention from Googles Flax, JAX, and Cloud team member about efficient deep learning frameworks. Intended uses Our model is intended to be used as a sentence and short paragraph encoder. Given an input text, it outputs a vector which captures the semantic information. The sentence vector may be used for information retrieval, clustering or sentence similarity tasks. By default, input text longer than 256 word pieces is truncated. Training procedure Pre-training We use the pretrained nreimers/MiniLM-L6-H384-uncased model. Please refer to the model card for more detailed information about the pre-training procedure. Fine-tuning We fine-tune the model using a contrastive objective. Formally, we compute the cosine similarity from each possible sentence pairs from the batch. We then apply the cross entropy loss by comparing with true pairs. Hyper parameters We trained our model on a TPU v3-8. We train the model during 100k steps using a batch size of 1024 (128 per TPU core). We use a learning rate warm up of 500. The sequence length was limited to 128 tokens. We used the AdamW optimizer with a 2e-5 learning rate. The full training script is accessible in this current repository: trainscript.py. Training data We use the concatenation from multiple datasets to fine-tune our model. The total number of sentence pairs is above 1 billion sentences. We sampled each dataset given a weighted probability which configuration is detailed in the dataconfig.json file.

cross-encoder/ms-marco-MiniLM-L6-v2

This model was trained on the MS Marco Passage Ranking task. The model can be used for Information Retrieval: Given a query, encode the query with all possible passages (e.g. retrieved with ElasticSearch). Then sort the passages in a decreasing order. See SBERT.net Retrieve & Re-rank for more details. The training code is available here: SBERT.net Training MS Marco Usage with SentenceTransformers The usage is easy when you have SentenceTransformers installed. Then you can use the pre-trained models like this: Usage with Transformers Performance In the following table, we provide various pre-trained Cross-Encoders together with their performance on the TREC Deep Learning 2019 and the MS Marco Passage Reranking dataset. | cross-encoder/ms-marco-TinyBERT-L2-v2 | 69.84 | 32.56 | 9000 | cross-encoder/ms-marco-MiniLM-L2-v2 | 71.01 | 34.85 | 4100 | cross-encoder/ms-marco-MiniLM-L4-v2 | 73.04 | 37.70 | 2500 | cross-encoder/ms-marco-MiniLM-L6-v2 | 74.30 | 39.01 | 1800 | cross-encoder/ms-marco-MiniLM-L12-v2 | 74.31 | 39.02 | 960 | cross-encoder/ms-marco-TinyBERT-L2 | 67.43 | 30.15 | 9000 | cross-encoder/ms-marco-TinyBERT-L4 | 68.09 | 34.50 | 2900 | cross-encoder/ms-marco-TinyBERT-L6 | 69.57 | 36.13 | 680 | cross-encoder/ms-marco-electra-base | 71.99 | 36.41 | 340 | nboost/pt-tinybert-msmarco | 63.63 | 28.80 | 2900 | nboost/pt-bert-base-uncased-msmarco | 70.94 | 34.75 | 340 | nboost/pt-bert-large-msmarco | 73.36 | 36.48 | 100 | Capreolus/electra-base-msmarco | 71.23 | 36.89 | 340 | amberoad/bert-multilingual-passage-reranking-msmarco | 68.40 | 35.54 | 330 | sebastian-hofstaetter/distilbert-cat-marginmse-T2-msmarco | 72.82 | 37.88 | 720 Note: Runtime was computed on a V100 GPU.

BAAI/bge-small-en-v1.5

feature-extraction · sentence-transformers

google/electra-base-discriminator

transformers

google-bert/bert-base-uncased

fill-mask · transformers

sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2

sentence-similarity · sentence-transformers

BAAI/bge-m3

sentence-similarity · sentence-transformers

google-t5/t5-small

translation · transformers

sentence-transformers/all-mpnet-base-v2

sentence-similarity · sentence-transformers

amazon/chronos-2

time-series-forecasting · chronos-forecasting

FacebookAI/xlm-roberta-base

XLM-RoBERTa model pre-trained on 2.5TB of filtered CommonCrawl data containing 100 languages. It was introduced in the paper Unsupervised Cross-lingual Representation Learning at Scale by Conneau et al. and first released in this repository. Disclaimer: The team releasing XLM-RoBERTa did not write a model card for this model so this model card has been written by the Hugging Face team. Model description XLM-RoBERTa is a multilingual version of RoBERTa. It is pre-trained on 2.5TB of filtered CommonCrawl data containing 100 languages. RoBERTa is a transformers model pretrained on a large corpus in a self-supervised fashion. This means it was pretrained on the raw texts only, with no humans labelling them in any way (which is why it can use lots of publicly available data) with an automatic process to generate inputs and labels from those texts. More precisely, it was pretrained with the Masked language modeling (MLM) objective. Taking a sentence, the model randomly masks 15% of the words in the input then run the entire masked sentence through the model and has to predict the masked words. This is different from traditional recurrent neural networks (RNNs) that usually see the words one after the other, or from autoregressive models like GPT which internally mask the future tokens. It allows the model to learn a bidirectional representation of the sentence. This way, the model learns an inner representation of 100 languages that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled sentences for instance, you can train a standard classifier using the features produced by the XLM-RoBERTa model as inputs. Intended uses & limitations You can use the raw model for masked language modeling, but it's mostly intended to be fine-tuned on a downstream task. See the model hub to look for fine-tuned versions on a task that interests you. Note that this model is primarily aimed at being fine-tuned on tasks that use the whole sentence (potentially masked) to make decisions, such as sequence classification, token classification or question answering. For tasks such as text generation, you should look at models like GPT2. Usage You can use this model directly with a pipeline for masked language modeling: Here is how to use this model to get the features of a given text in PyTorch: BibTeX entry and citation info

Qwen/Qwen3-0.6B

Qwen3 is the latest generation of large language models in Qwen series, offering a comprehensive suite of dense and mixture-of-experts (MoE) models. Built upon extensive training, Qwen3 delivers groundbreaking advancements in reasoning, instruction-following, agent capabilities, and multilingual support, with the following key features: Uniquely support of seamless switching between thinking mode (for complex logical reasoning, math, and coding) and non-thinking mode (for efficient, general-purpose dialogue) within single model, ensuring optimal performance across various scenarios. Significantly enhancement in its reasoning capabilities, surpassing previous QwQ (in thinking mode) and Qwen2.5 instruct models (in non-thinking mode) on mathematics, code generation, and commonsense logical reasoning. Superior human preference alignment, excelling in creative writing, role-playing, multi-turn dialogues, and instruction following, to deliver a more natural, engaging, and immersive conversational experience. Expertise in agent capabilities, enabling precise integration with external tools in both thinking and unthinking modes and achieving leading performance among open-source models in complex agent-based tasks. Support of 100+ languages and dialects with strong capabilities for multilingual instruction following and translation. Model Overview Qwen3-0.6B has the following features: Type: Causal Language Models Training Stage: Pretraining & Post-training Number of Parameters: 0.6B Number of Paramaters (Non-Embedding): 0.44B Number of Layers: 28 Number of Attention Heads (GQA): 16 for Q and 8 for KV Context Length: 32,768 For more details, including benchmark evaluation, hardware requirements, and inference performance, please refer to our blog, GitHub, and Documentation. [!TIP] If you encounter significant endless repetitions, please refer to the Best Practices section for optimal sampling parameters, and set the presencepenalty to 1.5. Quickstart The code of Qwen3 has been in the latest Hugging Face transformers and we advise you to use the latest version of transformers. With transformers =0.4.6.post1 or vllm>=0.8.5 or to create an OpenAI-compatible API endpoint: SGLang: vLLM: For local use, applications such as Ollama, LMStudio, MLX-LM, llama.cpp, and KTransformers have also supported Qwen3. Switching Between Thinking and Non-Thinking Mode [!TIP] The enablethinking switch is also available in APIs created by SGLang and vLLM. Please refer to our documentation for SGLang and vLLM users. enablethinking=True By default, Qwen3 has thinking capabilities enabled, similar to QwQ-32B. This means the model will use its reasoning abilities to enhance the quality of generated responses. For example, when explicitly setting enablethinking=True or leaving it as the default value in tokenizer.applychattemplate, the model will engage its thinking mode. In this mode, the model will generate think content wrapped in a ... block, followed by the final response. [!NOTE] For thinking mode, use Temperature=0.6, TopP=0.95, TopK=20, and MinP=0 (the default setting in generationconfig.json). DO NOT use greedy decoding, as it can lead to performance degradation and endless repetitions. For more detailed guidance, please refer to the Best Practices section. enablethinking=False We provide a hard switch to strictly disable the model's thinking behavior, aligning its functionality with the previous Qwen2.5-Instruct models. This mode is particularly useful in scenarios where disabling thinking is essential for enhancing efficiency. In this mode, the model will not generate any think content and will not include a ... block. [!NOTE] For non-thinking mode, we suggest using Temperature=0.7, TopP=0.8, TopK=20, and MinP=0. For more detailed guidance, please refer to the Best Practices section. Advanced Usage: Switching Between Thinking and Non-Thinking Modes via User Input…

openai/clip-vit-base-patch32

Disclaimer: The model card is taken and modified from the official CLIP repository, it can be found here. Model Details The CLIP model was developed by researchers at OpenAI to learn about what contributes to robustness in computer vision tasks. The model was also developed to test the ability of models to generalize to arbitrary image classification tasks in a zero-shot manner. It was not developed for general model deployment - to deploy models like CLIP, researchers will first need to carefully study their capabilities in relation to the specific context they’re being deployed within. Model Date The model uses a ViT-B/32 Transformer architecture as an image encoder and uses a masked self-attention Transformer as a text encoder. These encoders are trained to maximize the similarity of (image, text) pairs via a contrastive loss. The original implementation had two variants: one using a ResNet image encoder and the other using a Vision Transformer. This repository has the variant with the Vision Transformer. Documents Blog Post CLIP Paper Use with Transformers Model Use Intended Use The model is intended as a research output for research communities. We hope that this model will enable researchers to better understand and explore zero-shot, arbitrary image classification. We also hope it can be used for interdisciplinary studies of the potential impact of such models - the CLIP paper includes a discussion of potential downstream impacts to provide an example for this sort of analysis. Primary intended uses The primary intended users of these models are AI researchers. We primarily imagine the model will be used by researchers to better understand robustness, generalization, and other capabilities, biases, and constraints of computer vision models. Out-of-Scope Use Cases Any deployed use case of the model - whether commercial or not - is currently out of scope. Non-deployed use cases such as image search in a constrained environment, are also not recommended unless there is thorough in-domain testing of the model with a specific, fixed class taxonomy. This is because our safety assessment demonstrated a high need for task specific testing especially given the variability of CLIP’s performance with different class taxonomies. This makes untested and unconstrained deployment of the model in any use case currently potentially harmful. Certain use cases which would fall under the domain of surveillance and facial recognition are always out-of-scope regardless of performance of the model. This is because the use of artificial intelligence for tasks such as these can be premature currently given the lack of testing norms and checks to ensure its fair use. Since the model has not been purposefully trained in or evaluated on any languages other than English, its use should be limited to English language use cases. Data The model was trained on publicly available image-caption data. This was done through a combination of crawling a handful of websites and using commonly-used pre-existing image datasets such as YFCC100M. A large portion of the data comes from our crawling of the internet. This means that the data is more representative of people and societies most connected to the internet which tend to skew towards more developed nations, and younger, male users. Data Mission Statement Our goal with building this dataset was to test out robustness and generalizability in computer vision tasks. As a result, the focus was on gathering large quantities of data from different publicly-available internet data sources. The data was gathered in a mostly non-interventionist manner. However, we only crawled websites that had policies against excessively violent and adult images and allowed us to filter out such content. We do not intend for this dataset to be used as the basis for any commercial or deployed model and will not be releasing the dataset. Performance and Limitations Performance…

Comfy-Org/MiniMax-H3

Original model repository: https://huggingface.co/MiniMaxAI/MiniMax-H3 https://huggingface.co/lightx2v/Minimax-h3-Turbo https://huggingface.co/alibaba-pai/MiniMax-H3-Fun-Controlnet-Union https://huggingface.co/Kijai/MiniMax-H3-experimental The Qwen3-VL-32B nvfp4awq quant is converted from: https://huggingface.co/cybermotaz/Qwen3-VL-32B-Instruct-NVFP4 This nvfp4 text encoder does not require Blackwell GPU to use. For diffusion models prefer int8convrot if you are able to use pytorch with cu130. fp8scaled should only be used if you cannot use int8convrot. Place the files in the following folders: Workflows I2V：https://github.com/Comfy-Org/workflowtemplates/blob/main/templates/videominimaxh3i2v.json T2V：https://github.com/Comfy-Org/workflowtemplates/blob/main/templates/videominimaxh3t2v.json R2V：https://github.com/Comfy-Org/workflowtemplates/blob/main/templates/videominimaxh3r2v.json Doc: https://docs.comfy.org/tutorials/video/minimax/minimax-h3 Embeddings To use the embeddings in a text prompt, invoke them in the CLIPTextEncode node by combining embedding: with the filename of the embedding like this for minimaxh3artisexplosion: Just exchange the minimaxh3artisexplosion part with the filename of the embedding you want to use.

BAAI/bge-reranker-v2-m3

More details please refer to our Github: FlagEmbedding. Model List Usage Fine-tuning Evaluation Citation Different from embedding model, reranker uses question and document as input and directly output similarity instead of embedding. You can get a relevance score by inputting query and passage to the reranker. And the score can be mapped to a float value in [0,1] by sigmoid function. Model List You can select the model according your senario and resource. For multilingual, utilize BAAI/bge-reranker-v2-m3 and BAAI/bge-reranker-v2-gemma For Chinese or English, utilize BAAI/bge-reranker-v2-m3 and BAAI/bge-reranker-v2-minicpm-layerwise. For efficiency, utilize BAAI/bge-reranker-v2-m3 and the low layer of BAAI/bge-reranker-v2-minicpm-layerwise. For better performance, recommand BAAI/bge-reranker-v2-minicpm-layerwise and BAAI/bge-reranker-v2-gemma Usage Using FlagEmbedding For normal reranker (bge-reranker-base / bge-reranker-large / bge-reranker-v2-m3 ) Get relevance scores (higher scores indicate more relevance): For LLM-based reranker For LLM-based layerwise reranker Using Huggingface transformers For normal reranker (bge-reranker-base / bge-reranker-large / bge-reranker-v2-m3 ) Get relevance scores (higher scores indicate more relevance): For LLM-based reranker For LLM-based layerwise reranker Fine-tune Data Format Train data should be a json file, where each line is a dict like this: query is the query, and pos is a list of positive texts, neg is a list of negative texts, prompt indicates the relationship between query and texts. If you have no negative texts for a query, you can random sample some from the entire corpus as the negatives. See toyfinetunedata.jsonl for a toy data file. Train You can fine-tune the reranker with the following code: Our rerankers are initialized from google/gemma-2b (for llm-based reranker) and openbmb/MiniCPM-2B-dpo-bf16 (for llm-based layerwise reranker), and we train it on a mixture of multilingual datasets: bge-m3-data quora train data fever train data Evaluation llama-index. BEIR. rereank the top 100 results from bge-en-v1.5 large. rereank the top 100 results from e5 mistral 7b instruct. CMTEB-retrieval. It rereank the top 100 results from bge-zh-v1.5 large. miracl (multi-language). It rereank the top 100 results from bge-m3. Citation If you find this repository useful, please consider giving a star and citation

trl-internal-testing/tiny-Qwen2ForCausalLM-2.5

This is a minimal model built for unit tests in the TRL library.

Comfy-Org/stable-diffusion-v1-5-archive

Original model repository: https://huggingface.co/runwayml/stable-diffusion-v1-5 Place the files in the following folders: This is an archival re-upload of Stable Diffusion v1.5, originally at https://huggingface.co/runwayml/stable-diffusion-v1-5 until RunwayML took down that page. This model is from 2022, and is several major generational upgrades behind, it is being preserved here for technical & accessibility reasons (eg legacy model testing).

timm/mobilenetv3_small_100.lamb_in1k

Model card for mobilenetv3small100.lambin1k A MobileNet-v3 image classification model. Trained on ImageNet-1k in timm using recipe template described below. Recipe details: A LAMB optimizer based recipe that is similar to ResNet Strikes Back A2 but 50% longer with EMA weight averaging, no CutMix Step (exponential decay w/ staircase) LR schedule with warmup Model Details Model Type: Image classification / feature backbone Model Stats: Params (M): 2.5 GMACs: 0.1 Activations (M): 1.4 Image size: 224 x 224 Papers: Searching for MobileNetV3: https://arxiv.org/abs/1905.02244 Dataset: ImageNet-1k Original: https://github.com/huggingface/pytorch-image-models Model Usage Image Classification Feature Map Extraction Image Embeddings Model Comparison Explore the dataset and runtime metrics of this model in timm model results. Citation

nomic-ai/nomic-embed-text-v1.5

nomic-embed-text-v1.5: Resizable Production Embeddings with Matryoshka Representation Learning Blog | Technical Report | AWS SageMaker | Nomic Platform Exciting Update!: nomic-embed-text-v1.5 is now multimodal! nomic-embed-vision-v1.5 is aligned to the embedding space of nomic-embed-text-v1.5, meaning any text embedding is multimodal! Usage Important: the text prompt must include a task instruction prefix, instructing the model which task is being performed. For example, if you are implementing a RAG application, you embed your documents as searchdocument: and embed your user queries as searchquery: . Notice: From transformers v5.5.0 and sentence transformers v5.3.0, trustremotecode=True will no longer be necessary. This will only be possible with the text-only series as of now. Task instruction prefixes searchdocument Purpose: embed texts as documents from a dataset This prefix is used for embedding texts as documents, for example as documents for a RAG index. searchquery Purpose: embed texts as questions to answer This prefix is used for embedding texts as questions that documents from a dataset could resolve, for example as queries to be answered by a RAG application. clustering Purpose: embed texts to group them into clusters This prefix is used for embedding texts in order to group them into clusters, discover common topics, or remove semantic duplicates. classification Purpose: embed texts to classify them This prefix is used for embedding texts into vectors that will be used as features for a classification model Sentence Transformers Transformers The model natively supports scaling of the sequence length past 2048 tokens. To do so, Transformers.js Nomic API The easiest way to use Nomic Embed is through the Nomic Embedding API. Generating embeddings with the nomic Python client is as easy as For more information, see the API reference Infinity Usage with Infinity. Adjusting Dimensionality nomic-embed-text-v1.5 is an improvement upon Nomic Embed that utilizes Matryoshka Representation Learning which gives developers the flexibility to trade off the embedding size for a negligible reduction in performance. Training Click the Nomic Atlas map below to visualize a 5M sample of our contrastive pretraining data! We train our embedder using a multi-stage training pipeline. Starting from a long-context BERT model, the first unsupervised contrastive stage trains on a dataset generated from weakly related text pairs, such as question-answer pairs from forums like StackExchange and Quora, title-body pairs from Amazon reviews, and summarizations from news articles. In the second finetuning stage, higher quality labeled datasets such as search queries and answers from web searches are leveraged. Data curation and hard-example mining is crucial in this stage. For more details, see the Nomic Embed Technical Report and corresponding blog post. Training data to train the models is released in its entirety. For more details, see the contrastors repository Join the Nomic Community Nomic: https://nomic.ai Discord: https://discord.gg/myY5YDR8z8 Twitter: https://twitter.com/nomicai Citation If you find the model, dataset, or training code useful, please cite our work

Qwen/Qwen3-VL-8B-Instruct

Meet Qwen3-VL — the most powerful vision-language model in the Qwen series to date. This generation delivers comprehensive upgrades across the board: superior text understanding & generation, deeper visual perception & reasoning, extended context length, enhanced spatial and video dynamics comprehension, and stronger agent interaction capabilities. Available in Dense and MoE architectures that scale from edge to cloud, with Instruct and reasoning‑enhanced Thinking editions for flexible, on‑demand deployment. Key Enhancements: Visual Agent: Operates PC/mobile GUIs—recognizes elements, understands functions, invokes tools, completes tasks. Visual Coding Boost: Generates Draw.io/HTML/CSS/JS from images/videos. Advanced Spatial Perception: Judges object positions, viewpoints, and occlusions; provides stronger 2D grounding and enables 3D grounding for spatial reasoning and embodied AI. Long Context & Video Understanding: Native 256K context, expandable to 1M; handles books and hours-long video with full recall and second-level indexing. Enhanced Multimodal Reasoning: Excels in STEM/Math—causal analysis and logical, evidence-based answers. Upgraded Visual Recognition: Broader, higher-quality pretraining is able to “recognize everything”—celebrities, anime, products, landmarks, flora/fauna, etc. Expanded OCR: Supports 32 languages (up from 19); robust in low light, blur, and tilt; better with rare/ancient characters and jargon; improved long-document structure parsing. Text Understanding on par with pure LLMs: Seamless text–vision fusion for lossless, unified comprehension. Model Architecture Updates: 1. Interleaved-MRoPE: Full‑frequency allocation over time, width, and height via robust positional embeddings, enhancing long‑horizon video reasoning. 2. DeepStack: Fuses multi‑level ViT features to capture fine‑grained details and sharpen image–text alignment. 3. Text–Timestamp Alignment: Moves beyond T‑RoPE to precise, timestamp‑grounded event localization for stronger video temporal modeling. This is the weight repository for Qwen3-VL-8B-Instruct. Below, we provide simple examples to show how to use Qwen3-VL with 🤖 ModelScope and 🤗 Transformers. The code of Qwen3-VL has been in the latest Hugging Face transformers and we advise you to build from source with command: Using 🤗 Transformers to Chat Here we show a code snippet to show how to use the chat model with transformers: Generation Hyperparameters VL Text Citation If you find our work helpful, feel free to give us a cite.

openai-community/gpt2

Test the whole generation capabilities here: https://transformer.huggingface.co/doc/gpt2-large Pretrained model on English language using a causal language modeling (CLM) objective. It was introduced in this paper and first released at this page. Disclaimer: The team releasing GPT-2 also wrote a model card for their model. Content from this model card has been written by the Hugging Face team to complete the information they provided and give specific examples of bias. Model description GPT-2 is a transformers model pretrained on a very large corpus of English data in a self-supervised fashion. This means it was pretrained on the raw texts only, with no humans labelling them in any way (which is why it can use lots of publicly available data) with an automatic process to generate inputs and labels from those texts. More precisely, it was trained to guess the next word in sentences. More precisely, inputs are sequences of continuous text of a certain length and the targets are the same sequence, shifted one token (word or piece of word) to the right. The model uses internally a mask-mechanism to make sure the predictions for the token i only uses the inputs from 1 to i but not the future tokens. This way, the model learns an inner representation of the English language that can then be used to extract features useful for downstream tasks. The model is best at what it was pretrained for however, which is generating texts from a prompt. This is the smallest version of GPT-2, with 124M parameters. Related Models: GPT-Large, GPT-Medium and GPT-XL Intended uses & limitations You can use the raw model for text generation or fine-tune it to a downstream task. See the model hub to look for fine-tuned versions on a task that interests you. How to use You can use this model directly with a pipeline for text generation. Since the generation relies on some randomness, we set a seed for reproducibility: Here is how to use this model to get the features of a given text in PyTorch: The training data used for this model has not been released as a dataset one can browse. We know it contains a lot of unfiltered content from the internet, which is far from neutral. As the openAI team themselves point out in their model card: Because large-scale language models like GPT-2 do not distinguish fact from fiction, we don’t support use-cases that require the generated text to be true. Additionally, language models like GPT-2 reflect the biases inherent to the systems they were trained on, so we do not recommend that they be deployed into systems that interact with humans > unless the deployers first carry out a study of biases relevant to the intended use-case. We found no statistically significant difference in gender, race, and religious bias probes between 774M and 1.5B, implying all versions of GPT-2 should be approached with similar levels of caution around use cases that are sensitive to biases around human attributes. Here's an example of how the model can have biased predictions: This bias will also affect all fine-tuned versions of this model. Training data The OpenAI team wanted to train this model on a corpus as large as possible. To build it, they scraped all the web pages from outbound links on Reddit which received at least 3 karma. Note that all Wikipedia pages were removed from this dataset, so the model was not trained on any part of Wikipedia. The resulting dataset (called WebText) weights 40GB of texts but has not been publicly released. You can find a list of the top 1,000 domains present in WebText here. Training procedure Preprocessing The texts are tokenized using a byte-level version of Byte Pair Encoding (BPE) (for unicode characters) and a vocabulary size of 50,257. The inputs are sequences of 1024 consecutive tokens. The larger model was trained on 256 cloud TPU v3 cores. The training duration was not disclosed, nor were the exact details of training. Evaluation results…

jonatasgrosman/wav2vec2-large-xlsr-53-japanese

automatic-speech-recognition · transformers

Qwen/Qwen3-8B

Qwen3 is the latest generation of large language models in Qwen series, offering a comprehensive suite of dense and mixture-of-experts (MoE) models. Built upon extensive training, Qwen3 delivers groundbreaking advancements in reasoning, instruction-following, agent capabilities, and multilingual support, with the following key features: Uniquely support of seamless switching between thinking mode (for complex logical reasoning, math, and coding) and non-thinking mode (for efficient, general-purpose dialogue) within single model, ensuring optimal performance across various scenarios. Significantly enhancement in its reasoning capabilities, surpassing previous QwQ (in thinking mode) and Qwen2.5 instruct models (in non-thinking mode) on mathematics, code generation, and commonsense logical reasoning. Superior human preference alignment, excelling in creative writing, role-playing, multi-turn dialogues, and instruction following, to deliver a more natural, engaging, and immersive conversational experience. Expertise in agent capabilities, enabling precise integration with external tools in both thinking and unthinking modes and achieving leading performance among open-source models in complex agent-based tasks. Support of 100+ languages and dialects with strong capabilities for multilingual instruction following and translation. Model Overview Qwen3-8B has the following features: Type: Causal Language Models Training Stage: Pretraining & Post-training Number of Parameters: 8.2B Number of Paramaters (Non-Embedding): 6.95B Number of Layers: 36 Number of Attention Heads (GQA): 32 for Q and 8 for KV Context Length: 32,768 natively and 131,072 tokens with YaRN. For more details, including benchmark evaluation, hardware requirements, and inference performance, please refer to our blog, GitHub, and Documentation. Quickstart The code of Qwen3 has been in the latest Hugging Face transformers and we advise you to use the latest version of transformers. With transformers =0.4.6.post1 or vllm>=0.8.5 or to create an OpenAI-compatible API endpoint: SGLang: vLLM: For local use, applications such as Ollama, LMStudio, MLX-LM, llama.cpp, and KTransformers have also supported Qwen3. Switching Between Thinking and Non-Thinking Mode [!TIP] The enablethinking switch is also available in APIs created by SGLang and vLLM. Please refer to our documentation for SGLang and vLLM users. enablethinking=True By default, Qwen3 has thinking capabilities enabled, similar to QwQ-32B. This means the model will use its reasoning abilities to enhance the quality of generated responses. For example, when explicitly setting enablethinking=True or leaving it as the default value in tokenizer.applychattemplate, the model will engage its thinking mode. In this mode, the model will generate think content wrapped in a ... block, followed by the final response. [!NOTE] For thinking mode, use Temperature=0.6, TopP=0.95, TopK=20, and MinP=0 (the default setting in generationconfig.json). DO NOT use greedy decoding, as it can lead to performance degradation and endless repetitions. For more detailed guidance, please refer to the Best Practices section. enablethinking=False We provide a hard switch to strictly disable the model's thinking behavior, aligning its functionality with the previous Qwen2.5-Instruct models. This mode is particularly useful in scenarios where disabling thinking is essential for enhancing efficiency. In this mode, the model will not generate any think content and will not include a ... block. [!NOTE] For non-thinking mode, we suggest using Temperature=0.7, TopP=0.8, TopK=20, and MinP=0. For more detailed guidance, please refer to the Best Practices section. Advanced Usage: Switching Between Thinking and Non-Thinking Modes via User Input We provide a soft switch mechanism that allows users to dynamically control the model's behavior when enablethinking=True.…

BAAI/bge-large-en-v1.5

Model List | FAQ | Usage | Evaluation | Train | Contact | Citation | License For more details please refer to our Github: FlagEmbedding. If you are looking for a model that supports more languages, longer texts, and other retrieval methods, you can try using bge-m3. FlagEmbedding focuses on retrieval-augmented LLMs, consisting of the following projects currently: Long-Context LLM: Activation Beacon Fine-tuning of LM : LM-Cocktail Dense Retrieval: BGE-M3, LLM Embedder, BGE Embedding Reranker Model: BGE Reranker Benchmark: C-MTEB News 1/30/2024: Release BGE-M3, a new member to BGE model series! M3 stands for Multi-linguality (100+ languages), Multi-granularities (input length up to 8192), Multi-Functionality (unification of dense, lexical, multi-vec/colbert retrieval). It is the first embedding model that supports all three retrieval methods, achieving new SOTA on multi-lingual (MIRACL) and cross-lingual (MKQA) benchmarks. Technical Report and Code. :fire: 1/9/2024: Release Activation-Beacon, an effective, efficient, compatible, and low-cost (training) method to extend the context length of LLM. Technical Report :fire: 12/24/2023: Release LLaRA, a LLaMA-7B based dense retriever, leading to state-of-the-art performances on MS MARCO and BEIR. Model and code will be open-sourced. Please stay tuned. Technical Report :fire: 11/23/2023: Release LM-Cocktail, a method to maintain general capabilities during fine-tuning by merging multiple language models. Technical Report :fire: 10/12/2023: Release LLM-Embedder, a unified embedding model to support diverse retrieval augmentation needs for LLMs. Technical Report 09/15/2023: The technical report and massive training data of BGE has been released 09/12/2023: New models: New reranker model: release cross-encoder models BAAI/bge-reranker-base and BAAI/bge-reranker-large, which are more powerful than embedding model. We recommend to use/fine-tune them to re-rank top-k documents returned by embedding models. update embedding model: release bge--v1.5 embedding model to alleviate the issue of the similarity distribution, and enhance its retrieval ability without instruction. More 09/07/2023: Update fine-tune code: Add script to mine hard negatives and support adding instruction during fine-tuning. 08/09/2023: BGE Models are integrated into Langchain, you can use it like this; C-MTEB leaderboard is available. 08/05/2023: Release base-scale and small-scale models, best performance among the models of the same size 🤗 08/02/2023: Release bge-large-(short for BAAI General Embedding) Models, rank 1st on MTEB and C-MTEB benchmark! :tada: :tada: 08/01/2023: We release the Chinese Massive Text Embedding Benchmark (C-MTEB), consisting of 31 test dataset. Model List bge is short for BAAI general embedding. [1\]: If you need to search the relevant passages to a query, we suggest to add the instruction to the query; in other cases, no instruction is needed, just use the original query directly. In all cases, no instruction needs to be added to passages. [2\]: Different from embedding model, reranker uses question and document as input and directly output similarity instead of embedding. To balance the accuracy and time cost, cross-encoder is widely used to re-rank top-k documents retrieved by other simple models. For examples, use bge embedding model to retrieve top 100 relevant documents, and then use bge reranker to re-rank the top 100 document to get the final top-3 results. All models have been uploaded to Huggingface Hub, and you can see them at https://huggingface.co/BAAI. If you cannot open the Huggingface Hub, you also can download the models at https://model.baai.ac.cn/models . Frequently asked questions 1. How to fine-tune bge embedding model? Following this example to prepare data and fine-tune your model. Some suggestions: Mine hard negatives following this example, which can improve the retrieval performance.…

unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF

See our collection for all versions of Qwen3 including GGUF, 4-bit & 16-bit formats. Learn to run Qwen3-Coder correctly - Read our Guide . See Unsloth Dynamic 2.0 GGUFs for our quantization benchmarks. ✨ Read our Qwen3-Coder Guide here ! Fine-tune Qwen3 (14B) for free using our Google Colab notebook! Read our Blog about Qwen3 support: unsloth.ai/blog/qwen3 View the rest of our notebooks in our docs here. Qwen3-Coder is available in multiple sizes. Today, we're excited to introduce Qwen3-Coder-30B-A3B-Instruct. This streamlined model maintains impressive performance and efficiency, featuring the following key enhancements: Significant Performance among open models on Agentic Coding, Agentic Browser-Use, and other foundational coding tasks. Long-context Capabilities with native support for 256K tokens, extendable up to 1M tokens using Yarn, optimized for repository-scale understanding. Agentic Coding supporting for most platform such as Qwen Code, CLINE, featuring a specially designed function call format. Model Overview Qwen3-Coder-30B-A3B-Instruct has the following features: Type: Causal Language Models Training Stage: Pretraining & Post-training Number of Parameters: 30.5B in total and 3.3B activated Number of Layers: 48 Number of Attention Heads (GQA): 32 for Q and 4 for KV Number of Experts: 128 Number of Activated Experts: 8 Context Length: 262,144 natively. NOTE: This model supports only non-thinking mode and does not generate blocks in its output. Meanwhile, specifying enablethinking=False is no longer required. For more details, including benchmark evaluation, hardware requirements, and inference performance, please refer to our blog, GitHub, and Documentation. Quickstart We advise you to use the latest version of transformers. With transformers<4.51.0, you will encounter the following error: The following contains a code snippet illustrating how to use the model generate content based on given inputs. Note: If you encounter out-of-memory (OOM) issues, consider reducing the context length to a shorter value, such as 32,768. For local use, applications such as Ollama, LMStudio, MLX-LM, llama.cpp, and KTransformers have also supported Qwen3. Agentic Coding Qwen3-Coder excels in tool calling capabilities. You can simply define or use any tools as following example. Best Practices To achieve optimal performance, we recommend the following settings: 1. Sampling Parameters: We suggest using temperature=0.7, topp=0.8, topk=20, repetitionpenalty=1.05. 2. Adequate Output Length: We recommend using an output length of 65,536 tokens for most queries, which is adequate for instruct models. Citation If you find our work helpful, feel free to give us a cite.

Qwen/Qwen3.6-35B-A3B-FP8

[!Note] This repository contains FP8-quantized model weights and configuration files for the post-trained model in the Hugging Face Transformers format. These artifacts are compatible with Hugging Face Transformers, vLLM, SGLang, KTransformers, etc. The quantization method is fine-grained fp8 quantization with block size of 128, and its performance metrics are nearly identical to those of the original model. Following the February release of the Qwen3.5 series, we're pleased to share the first open-weight variant of Qwen3.6. Built on direct feedback from the community, Qwen3.6 prioritizes stability and real-world utility, offering developers a more intuitive, responsive, and genuinely productive coding experience. Qwen3.6 Highlights This release delivers substantial upgrades, particularly in Agentic Coding: the model now handles frontend workflows and repository-level reasoning with greater fluency and precision. Thinking Preservation: we've introduced a new option to retain reasoning context from historical messages, streamlining iterative development and reducing overhead. For more details, please refer to our blog post Qwen3.6-35B-A3B. Model Overview Type: Causal Language Model with Vision Encoder Training Stage: Pre-training & Post-training Language Model Number of Parameters: 35B in total and 3B activated Hidden Dimension: 2048 Token Embedding: 248320 (Padded) Number of Layers: 40 Hidden Layout: 10 × (3 × (Gated DeltaNet → MoE) → 1 × (Gated Attention → MoE)) Gated DeltaNet: Number of Linear Attention Heads: 32 for V and 16 for QK Head Dimension: 128 Gated Attention: Number of Attention Heads: 16 for Q and 2 for KV Head Dimension: 256 Rotary Position Embedding Dimension: 64 Mixture Of Experts Number of Experts: 256 Number of Activated Experts: 8 Routed + 1 Shared Expert Intermediate Dimension: 512 LM Output: 248320 (Padded) MTP: trained with multi-steps Context Length: 262,144 natively and extensible up to 1,010,000 tokens. Benchmark Results Language Qwen3.5-27B Gemma4-31B Qwen3.5-35BA3B Gemma4-26BA4B Qwen3.6-35BA3B SWE-bench Verified 75.0 52.0 70.0 17.4 73.4 SWE-bench Multilingual 69.3 51.7 60.3 17.3 67.2 Terminal-Bench 2.0 41.6 42.9 40.5 34.2 51.5 Claw-Eval Pass^3 46.2 25.0 51.0 28.0 50.0 SkillsBench Avg5 27.2 23.6 4.4 12.3 28.7 LiveCodeBench v6 80.7 80.0 74.6 77.1 80.4 AIME26 92.6 89.2 91.0 88.3 92.7 SWE-Bench Series: Internal agent scaffold (bash + file-edit tools); temp=1.0, topp=0.95, 200K context window. We correct some problematic tasks in the public set of SWE-bench Pro and evaluate all baselines on the refined benchmark. Terminal-Bench 2.0: Harbor/Terminus-2 harness; 3h timeout, 32 CPU/48 GB RAM; temp=1.0, topp=0.95, topk=20, maxtokens=80K, 256K ctx; avg of 5 runs. SkillsBench: Evaluated via OpenCode on 78 tasks (self-contained subset, excluding API-dependent tasks); avg of 5 runs. NL2Repo: Others are evaluated via Claude Code (temp=1.0, topp=0.95, maxturns=900). QwenClawBench: An internal real-user-distribution Claw agent benchmark (open-sourcing soon); temp=0.6, 256K ctx. QwenWebBench: An internal front-end code generation benchmark; bilingual (EN/CN), 7 categories (Web Design, Web Apps, Games, SVG, Data Visualization, Animation, and 3D); auto-render + multimodal judge (code/visual correctness); BT/Elo rating system. TAU3-Bench: We use the official user model (gpt-5.2, low reasoning effort) + default BM25 retrieval. VITA-Bench: Avg subdomain scores; using claude-4-sonnet as judger, as the official judger (claude-3.7-sonnet) is no longer available. MCPMark: GitHub MCP v0.30.3; Playwright responses truncated at 32K tokens. MCP-Atlas: Public set score; gemini-2.5-pro judger. AIME 26: We use the full AIME 2026 (I & II), where the scores may differ from Qwen 3.5 notes. Vision Language Qwen3.5-27B Claude-Sonnet-4.5 Gemma4-31B Gemma4-26BA4B Qwen3.5-35B-A3B Qwen3.6-35B-A3B Mathvista(mini) 87.8 79.8 79.3 79.4 86.2 86.4 ZEROBenchsub 36.2 26.3 26.0 26.3 34.1 34.4 RealWorldQA 83.7 70.3 72.3 72.2 84.1 85.3…

intfloat/multilingual-e5-small

Multilingual E5 Text Embeddings: A Technical Report. Liang Wang, Nan Yang, Xiaolong Huang, Linjun Yang, Rangan Majumder, Furu Wei, arXiv 2024 This model has 12 layers and the embedding size is 384. Usage Below is an example to encode queries and passages from the MS-MARCO passage ranking dataset. Supported Languages This model is initialized from microsoft/Multilingual-MiniLM-L12-H384 and continually trained on a mixture of multilingual datasets. It supports 100 languages from xlm-roberta, but low-resource languages may see performance degradation. Training Details Initialization: microsoft/Multilingual-MiniLM-L12-H384 First stage: contrastive pre-training with weak supervision For all labeled datasets, we only use its training set for fine-tuning. For other training details, please refer to our paper at https://arxiv.org/pdf/2402.05672. Benchmark Results on Mr. TyDi Check out unilm/e5 to reproduce evaluation results on the BEIR and MTEB benchmark. Support for Sentence Transformers Below is an example for usage with sentencetransformers. 1. Do I need to add the prefix "query: " and "passage: " to input texts? Yes, this is how the model is trained, otherwise you will see a performance degradation. Here are some rules of thumb: Use "query: " and "passage: " correspondingly for asymmetric tasks such as passage retrieval in open QA, ad-hoc information retrieval. Use "query: " prefix for symmetric tasks such as semantic similarity, bitext mining, paraphrase retrieval. Use "query: " prefix if you want to use embeddings as features, such as linear probing classification, clustering. 2. Why are my reproduced results slightly different from reported in the model card? Different versions of transformers and pytorch could cause negligible but non-zero performance differences. 3. Why does the cosine similarity scores distribute around 0.7 to 1.0? This is a known and expected behavior as we use a low temperature 0.01 for InfoNCE contrastive loss. For text embedding tasks like text retrieval or semantic similarity, what matters is the relative order of the scores instead of the absolute values, so this should not be an issue. Citation If you find our paper or models helpful, please consider cite as follows: Limitations Long texts will be truncated to at most 512 tokens.

timm/efficientnet_b3.ra2_in1k

A EfficientNet image classification model. Trained on ImageNet-1k in timm using recipe template described below. Recipe details: RandAugment RA2 recipe. Inspired by and evolved from EfficientNet RandAugment recipes. Published as B recipe in ResNet Strikes Back. RMSProp (TF 1.0 behaviour) optimizer, EMA weight averaging Step (exponential decay w/ staircase) LR schedule with warmup Model Details Model Type: Image classification / feature backbone Model Stats: Params (M): 12.2 GMACs: 1.6 Activations (M): 21.5 Image size: train = 288 x 288, test = 320 x 320 Papers: EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks: https://arxiv.org/abs/1905.11946 ResNet strikes back: An improved training procedure in timm: https://arxiv.org/abs/2110.00476 Dataset: ImageNet-1k Original: https://github.com/huggingface/pytorch-image-models Model Usage Image Classification Feature Map Extraction Image Embeddings Model Comparison Explore the dataset and runtime metrics of this model in timm model results. Citation

argmaxinc/whisperkit-coreml

WhisperKit Repo WhisperKit is part of Argmax OSS, an On-device Speech AI SDK for Apple Silicon: https://github.com/argmaxinc/argmax-oss-swift Paper Check out the WhisperKit paper and presentation from ICML 2025: https://icml.cc/virtual/2025/47854 Pro For real-time transcription with speakers and custom vocabulary, check out Argmax Pro SDK: https://www.argmaxinc.com/blog/argmax-sdk-2

hexgrad/Kokoro-82M

Kokoro is an open-weight TTS model with 82 million parameters. Despite its lightweight architecture, it delivers comparable quality to larger models while being significantly faster and more cost-efficient. With Apache-licensed weights, Kokoro can be deployed anywhere from production environments to personal projects. 🐈 GitHub: https://github.com/hexgrad/kokoro 🚀 Demo: https://hf.co/spaces/hexgrad/Kokoro-TTS [!NOTE] As of April 2025, the market rate of Kokoro served over API is under $1 per million characters of text input, or under $0.06 per hour of audio output. (On average, 1000 characters of input is about 1 minute of output.) Sources: ArtificialAnalysis/Replicate at 65 cents per M chars and DeepInfra at 80 cents per M chars. This is an Apache-licensed model, and Kokoro has been deployed in numerous projects and commercial APIs. We welcome the deployment of the model in real use cases. [!CAUTION] Fake websites like kokorottsaicom (snapshot: https://archive.ph/nRRnk) and kokorottsnet (snapshot: https://archive.ph/60opa) are likely scams masquerading under the banner of a popular model. Any website containing "kokoro" in its root domain (e.g. kokorottsaicom, kokorottsnet) is NOT owned by and NOT affiliated with this model page or its author, and attempts to imply otherwise are red flags. Releases Usage EVAL.md ↗️ SAMPLES.md ↗️ VOICES.md ↗️ Model Facts Training Details Creative Commons Attribution Acknowledgements Releases | v0.19 | 2024 Dec 25 | [1] generated by closed [2] TTS models from large providers [1] https://copyright.gov/ai/aipolicyguidance.pdf [2] No synthetic audio from open TTS models or "custom voice clones" Total Dataset Size: A few hundred hours of audio Total Training Cost: About $1000 for 1000 hours of A100 80GB vRAM Creative Commons Attribution The following CC BY audio was part of the dataset used to train Kokoro v1.0.

Qwen/Qwen3.5-9B

[!Note] This repository contains model weights and configuration files for the post-trained model in the Hugging Face Transformers format. These artifacts are compatible with Hugging Face Transformers, vLLM, SGLang, KTransformers, etc. Over recent months, we have intensified our focus on developing foundation models that deliver exceptional utility and performance. Qwen3.5 represents a significant leap forward, integrating breakthroughs in multimodal learning, architectural efficiency, reinforcement learning scale, and global accessibility to empower developers and enterprises with unprecedented capability and efficiency. Qwen3.5 Highlights Qwen3.5 features the following enhancement: Unified Vision-Language Foundation: Early fusion training on multimodal tokens achieves cross-generational parity with Qwen3 and outperforms Qwen3-VL models across reasoning, coding, agents, and visual understanding benchmarks. Efficient Hybrid Architecture: Gated Delta Networks combined with sparse Mixture-of-Experts deliver high-throughput inference with minimal latency and cost overhead. Scalable RL Generalization: Reinforcement learning scaled across million-agent environments with progressively complex task distributions for robust real-world adaptability. Global Linguistic Coverage: Expanded support to 201 languages and dialects, enabling inclusive, worldwide deployment with nuanced cultural and regional understanding. Next-Generation Training Infrastructure: Near-100% multimodal training efficiency compared to text-only training and asynchronous RL frameworks supporting massive-scale agent scaffolds and environment orchestration. For more details, please refer to our blog post Qwen3.5. Model Overview Type: Causal Language Model with Vision Encoder Training Stage: Pre-training & Post-training Language Model Number of Parameters: 9B Hidden Dimension: 4096 Token Embedding: 248320 (Padded) Number of Layers: 32 Hidden Layout: 8 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN)) Gated DeltaNet: Number of Linear Attention Heads: 32 for V and 16 for QK Head Dimension: 128 Gated Attention: Number of Attention Heads: 16 for Q and 4 for KV Head Dimension: 256 Rotary Position Embedding Dimension: 64 Feed Forward Network: Intermediate Dimension: 12288 LM Output: 248320 (Padded) MTP: trained with multi-steps Context Length: 262,144 natively and extensible up to 1,010,000 tokens. Benchmark Results Language GPT-OSS-120B GPT-OSS-20B Qwen3-Next-80B-A3B-Thinking Qwen3-30BA3B-Thinking-2507 Qwen3.5-9B Qwen3.5-4B MMLU-Redux 91.0 87.8 92.5 91.4 91.1 88.8 GPQA Diamond 80.1 71.5 77.2 73.4 81.7 76.2 MultiChallenge 45.3 40.1 51.3 46.5 54.5 49.0 LongBench v2 48.2 45.6 48.0 44.8 55.2 50.0 HMMT Feb 25 90.0 76.7 73.7 63.1 83.2 74.0 HMMT Nov 25 90.0 81.8 81.2 73.8 82.9 76.8 LiveCodeBench v6 82.7 74.6 68.7 66.0 65.6 55.8 Global PIQA 84.1 79.8 83.5 80.2 83.2 78.9 MAXIFE 83.7 80.1 79.9 77.4 83.4 78.0 TAU2-Bench: we follow the official setup except for the airline domain, where all models are evaluated by applying the fixes proposed in the Claude Opus 4.5 system card. MMLU-ProX: we report the averaged accuracy on 29 languages. WMT24++: a harder subset of WMT24 after difficulty labeling and rebalancing; we report the averaged scores on 55 languages using XCOMET-XXL. MAXIFE: we report the accuracy on English + multilingual original prompts (totally 23 settings). Empty cells (--) indicate scores not yet available or not applicable. Vision Language GPT-5-Nano-2025-08-07 Gemini-2.5-Flash-Lite Qwen3-VL-30B-A3B Qwen3.5-9B Qwen3.5-4B Mathvista(mini) 71.5 72.8 81.9 85.7 85.1 BabyVision 14.4 17.5 18.6 28.6/25.8 16.0/19.1 MMBench EN-DEV-v1.1 80.3 82.7 88.9 90.1 89.4 Text Recognition and Document Understanding OmniDocBench1.5 55.9 79.4 86.8 87.7 86.2 MMLongBench-Doc 31.8 46.5 47.4 57.7 54.2 EmbSpatialBench 74.2 66.1 80.6 83.0 81.3 RefSpatialBench 12.6 11.2 54.2 58.5 54.6 VideoMME (w sub.) 71.7 74.6 79.9 84.5 83.5…

BAAI/bge-base-en-v1.5

Model List | FAQ | Usage | Evaluation | Train | Contact | Citation | License For more details please refer to our Github: FlagEmbedding. If you are looking for a model that supports more languages, longer texts, and other retrieval methods, you can try using bge-m3. FlagEmbedding focuses on retrieval-augmented LLMs, consisting of the following projects currently: Long-Context LLM: Activation Beacon Fine-tuning of LM : LM-Cocktail Dense Retrieval: BGE-M3, LLM Embedder, BGE Embedding Reranker Model: BGE Reranker Benchmark: C-MTEB News 1/30/2024: Release BGE-M3, a new member to BGE model series! M3 stands for Multi-linguality (100+ languages), Multi-granularities (input length up to 8192), Multi-Functionality (unification of dense, lexical, multi-vec/colbert retrieval). It is the first embedding model which supports all three retrieval methods, achieving new SOTA on multi-lingual (MIRACL) and cross-lingual (MKQA) benchmarks. Technical Report and Code. :fire: 1/9/2024: Release Activation-Beacon, an effective, efficient, compatible, and low-cost (training) method to extend the context length of LLM. Technical Report :fire: 12/24/2023: Release LLaRA, a LLaMA-7B based dense retriever, leading to state-of-the-art performances on MS MARCO and BEIR. Model and code will be open-sourced. Please stay tuned. Technical Report :fire: 11/23/2023: Release LM-Cocktail, a method to maintain general capabilities during fine-tuning by merging multiple language models. Technical Report :fire: 10/12/2023: Release LLM-Embedder, a unified embedding model to support diverse retrieval augmentation needs for LLMs. Technical Report 09/15/2023: The technical report and massive training data of BGE has been released 09/12/2023: New models: New reranker model: release cross-encoder models BAAI/bge-reranker-base and BAAI/bge-reranker-large, which are more powerful than embedding model. We recommend to use/fine-tune them to re-rank top-k documents returned by embedding models. update embedding model: release bge--v1.5 embedding model to alleviate the issue of the similarity distribution, and enhance its retrieval ability without instruction. More 09/07/2023: Update fine-tune code: Add script to mine hard negatives and support adding instruction during fine-tuning. 08/09/2023: BGE Models are integrated into Langchain, you can use it like this; C-MTEB leaderboard is available. 08/05/2023: Release base-scale and small-scale models, best performance among the models of the same size 🤗 08/02/2023: Release bge-large-(short for BAAI General Embedding) Models, rank 1st on MTEB and C-MTEB benchmark! :tada: :tada: 08/01/2023: We release the Chinese Massive Text Embedding Benchmark (C-MTEB), consisting of 31 test dataset. Model List bge is short for BAAI general embedding. [1\]: If you need to search the relevant passages to a query, we suggest to add the instruction to the query; in other cases, no instruction is needed, just use the original query directly. In all cases, no instruction needs to be added to passages. [2\]: Different from embedding model, reranker uses question and document as input and directly output similarity instead of embedding. To balance the accuracy and time cost, cross-encoder is widely used to re-rank top-k documents retrieved by other simple models. For examples, use bge embedding model to retrieve top 100 relevant documents, and then use bge reranker to re-rank the top 100 document to get the final top-3 results. All models have been uploaded to Huggingface Hub, and you can see them at https://huggingface.co/BAAI. If you cannot open the Huggingface Hub, you also can download the models at https://model.baai.ac.cn/models . Frequently asked questions 1. How to fine-tune bge embedding model? Following this example to prepare data and fine-tune your model. Some suggestions: Mine hard negatives following this example, which can improve the retrieval performance.…

unsloth/Qwen3.8-27B-GGUF

Unsloth Dynamic 3.0 achieves superior accuracy & outperforms other leading quants. Introducing Dynamic V3.0 GGUFs for SOTA accuracy and quantization performance Run and fine-tune Qwen3.8 in Unsloth Desktop with Thinking toggles . Download for Mac, Windows and Linux. GitHub repo Developer Role Support so Qwen3.8 can work in agentic tools like Codex and more! Tool calling improvements: Makes parsing nested objects to make tool calling succeed more. See below for 4-bit Qwen3.8-27B run inside of Unsloth Desktop: Analysis of best Qwen3.8 GGUF providers. Unsloth Dynamic v3.0 delivers >10% top-1% better accuracy at the same size compared to every other provider. Read more Following the widespread community adoption of the Qwen3.5 and Qwen3.6 series, we are pleased to introduce Qwen3.8, the most capable generation in the Qwen open-model family to date. Built on the architectural foundation of Qwen3.5, Qwen3.8 delivers substantial gains across coding, professional work, research, and long-horizon agentic tasks. Qwen3.8-27B brings these advances to a compact, deployment-friendly dense model: a native vision-language model that understands images and videos, with flexible thinking control, designed to carry complex, multi-step tasks through to completion with greater reliability. Qwen3.8 Highlights Qwen3.8-27B features the following enhancements: Core Capabilities: Comprehensive improvements across coding, professional work, research, and long-horizon agentic tasks. Agent Execution: Stronger autonomous planning and better handling of environment feedback, leading to more reliable end-to-end task completion. Downstream Compatibility: Broader support for popular harnesses and development tools, making it easier to integrate into your existing stack. Flexible Thinking Control: Thinking mode is on by default and can be disabled per request; reasoning depth can be tuned with reasoningeffort, and reasoning context from historical messages is retained via preservethinking. Vision-Language Understanding: Native support for image and video understanding, from STEM diagrams and documents to hour-scale videos. Model Overview Type: Causal Language Model with Vision Encoder Training Stage: Pre-training & Post-training Language Model Number of Parameters: 27B Hidden Dimension: 5120 Token Embedding: 248,320 (Padded) Number of Layers: 64 Hidden Layout: 16 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN)) Gated DeltaNet: Number of Linear Attention Heads: 48 for V and 16 for QK Head Dimension: 128 Gated Attention: Number of Attention Heads: 24 for Q and 4 for KV Head Dimension: 256 Rotary Position Embedding Dimension: 64 Feed Forward Network: Intermediate Dimension: 17,408 LM Output: 248,320 (Padded) MTP (Multi-Token Prediction): trained with multiple steps Context Length: 262,144 natively and extensible up to 1,000,000 tokens. Best Practices To achieve optimal performance, we recommend the following settings: 1. Sampling Parameters: We suggest using the following sets of sampling parameters: Thinking Mode: temperature=1.0, topp=0.95, topk=20, minp=0.0, presencepenalty=0.0, repetitionpenalty=1.0 Instruct (or non-thinking) mode: temperature=0.7, topp=0.80, topk=20, minp=0.0, presencepenalty=1.5, repetitionpenalty=1.0 For supported frameworks, you can adjust the presencepenalty parameter between 0 and 2 to reduce endless repetition. However, using a higher value may occasionally result in language mixing and a slight decrease in model performance. 2. Adequate Output Length: To optimize performance on agentic tasks, we recommend allocating sufficient output length to allow the model to generate detailed and comprehensive responses. For frameworks that support separate token limits for internal reasoning and final outputs, we suggest the following configuration within the 1M context length: Reasoning Content: Set the maximum output length to 262,144 tokens. Final Response: Set the maximum output length to 131,072 tokens.…

Qwen/Qwen2.5-7B-Instruct

Qwen2.5 is the latest series of Qwen large language models. For Qwen2.5, we release a number of base language models and instruction-tuned language models ranging from 0.5 to 72 billion parameters. Qwen2.5 brings the following improvements upon Qwen2: Significantly more knowledge and has greatly improved capabilities in coding and mathematics, thanks to our specialized expert models in these domains. Significant improvements in instruction following, generating long texts (over 8K tokens), understanding structured data (e.g, tables), and generating structured outputs especially JSON. More resilient to the diversity of system prompts, enhancing role-play implementation and condition-setting for chatbots. Long-context Support up to 128K tokens and can generate up to 8K tokens. Multilingual support for over 29 languages, including Chinese, English, French, Spanish, Portuguese, German, Italian, Russian, Japanese, Korean, Vietnamese, Thai, Arabic, and more. This repo contains the instruction-tuned 7B Qwen2.5 model, which has the following features: Type: Causal Language Models Training Stage: Pretraining & Post-training Architecture: transformers with RoPE, SwiGLU, RMSNorm, and Attention QKV bias Number of Parameters: 7.61B Number of Paramaters (Non-Embedding): 6.53B Number of Layers: 28 Number of Attention Heads (GQA): 28 for Q and 4 for KV Context Length: Full 131,072 tokens and generation 8192 tokens Please refer to this section for detailed instructions on how to deploy Qwen2.5 for handling long texts. For more details, please refer to our blog, GitHub, and Documentation. Requirements The code of Qwen2.5 has been in the latest Hugging face transformers and we advise you to use the latest version of transformers. With transformers<4.37.0, you will encounter the following error: Quickstart Here provides a code snippet with applychattemplate to show you how to load the tokenizer and model and how to generate contents. Processing Long Texts The current config.json is set for context length up to 32,768 tokens. To handle extensive inputs exceeding 32,768 tokens, we utilize YaRN, a technique for enhancing model length extrapolation, ensuring optimal performance on lengthy texts. For supported frameworks, you could add the following to config.json to enable YaRN: For deployment, we recommend using vLLM. Please refer to our Documentation for usage if you are not familar with vLLM. Presently, vLLM only supports static YARN, which means the scaling factor remains constant regardless of input length, potentially impacting performance on shorter texts. We advise adding the ropescaling configuration only when processing long contexts is required. Evaluation & Performance Detailed evaluation results are reported in this 📑 blog. For requirements on GPU memory and the respective throughput, see results here. Citation If you find our work helpful, feel free to give us a cite.

nvidia/Qwen3.6-35B-A3B-NVFP4

Model Overview Description: The NVIDIA Qwen3.6-35B-A3B-NVFP4 model is the quantized version of Alibaba's Qwen3.6-35B-A3B model, which is an auto-regressive language model that uses an optimized transformer architecture. For more information, please check here. The NVIDIA Qwen3.6-35B-A3B-NVFP4 model is quantized with Model Optimizer. This model is ready for commercial/non-commercial use. Third-Party Community Consideration This model is not owned or developed by NVIDIA. This model has been developed and built to a third-party’s requirements for this application and use case; see link to Non-NVIDIA (Qwen3.6-35B-A3B) Model Card from Alibaba. References NVIDIA Model Optimizer: https://github.com/NVIDIA/Model-Optimizer License/Terms of Use: GOVERNING DOWNLOAD TERMS: Use of the model is governed by the Apache license 2.0. Deployment Geography: Global Use Case: Developers looking to take off-the-shelf, pre-quantized models for deployment in AI Agent systems, chatbots, RAG systems, and other AI-powered applications. Release Date: Hugging Face on 05/28/2026 via https://huggingface.co/nvidia/Qwen3.6-35B-A3B-NVFP4 Model Architecture: Architecture Type: Transformers Network Architecture: Mixture-of-Experts (MoE) with Hybrid Attention Number of Model Parameters: 35B in total and 3B activated Input: Input Type(s): Text, Image, Video Input Format(s): String, Red, Green, Blue (RGB), Video (MP4/WebM) Input Parameters: One-Dimensional (1D), Two-Dimensional (2D), Three-Dimensional (3D) Other Properties Related to Input: Context length up to 262K Output: Output Type(s): Text Output Format: String Output Parameters: One-Dimensional(1D): Sequences Other Properties Related to Output: None Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA’s hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions. Software Integration: Supported Runtime Engine(s): vLLM Supported Hardware Microarchitecture Compatibility: NVIDIA Hopper, NVIDIA Blackwell The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment. Model Version(s): The model version is NVFP4 1.0 version and is Quantized with nvidia-modelopt v0.44.0 Training and Evaluation Datasets: Calibration Dataset: Link: cnndailymail, Nemotron-Post-Training-Dataset-v2 Data Collection Method by dataset: Automated. Labeling Method by dataset: Automated. Properties: The cnndailymail dataset is an English-language dataset containing just over 300k unique news articles as written by journalists at CNN and the Daily Mail. The Nemotron-Post-Training-Dataset-v2 is a post-training dataset curated by NVIDIA containing multi-turn conversations across diverse topics.…

Bingsu/adetailer

YOLOv8 Detection Model Datasets Face Anime Face CreateML xml2txt AN wider face Hand AnHDet hand-detection-fuao9 Person coco2017 (only person) AniSeg skytnt/anime-segmentation deepfashion2 deepfashion2 Since getattr is classified as a dangerous pickle function, any segmentation model that uses it is classified as unsafe. All models were created and saved using the official ultralytics library, so it's okay to use files downloaded from a trusted source. See also: https://huggingface.co/docs/hub/security-pickle

sentence-transformers/paraphrase-multilingual-mpnet-base-v2

sentence-transformers/paraphrase-multilingual-mpnet-base-v2 This is a sentence-transformers model: It maps sentences & paragraphs to a 768 dimensional dense vector space and can be used for tasks like clustering or semantic search. Usage (Sentence-Transformers) Using this model becomes easy when you have sentence-transformers installed: Then you can use the model like this: Usage (HuggingFace Transformers) Without sentence-transformers, you can use the model like this: First, you pass your input through the transformer model, then you have to apply the right pooling-operation on-top of the contextualized word embeddings. Usage (Text Embeddings Inference (TEI)) Text Embeddings Inference (TEI) is a blazing fast inference solution for text embedding models. CPU: NVIDIA GPU: Send a request to /v1/embeddings to generate embeddings via the OpenAI Embeddings API: Or check the Text Embeddings Inference API specification instead. Full Model Architecture Citing & Authors This model was trained by sentence-transformers. If you find this model helpful, feel free to cite our publication Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks:

pyannote/speaker-diarization-3.1

automatic-speech-recognition · pyannote-audio

autogluon/chronos-2

Update Jun 5, 2026: ☁️ Deploy Chronos-2 on AWS with AutoGluon-Cloud. Real-time, serverless, or batch inference in 3 lines of code — pandas DataFrames in, forecasts out. Check out the new deployment guide. Chronos-2 is a 120M-parameter, encoder-only time series foundation model for zero-shot forecasting. It supports univariate, multivariate, and covariate-informed tasks within a single architecture. Inspired by the T5 encoder, Chronos-2 produces multi-step-ahead quantile forecasts and uses a group attention mechanism for efficient in-context learning across related series and covariates. Trained on a combination of real-world and large-scale synthetic datasets, it achieves state-of-the-art zero-shot accuracy among public models on fev-bench, GIFT-Eval, and Chronos Benchmark II. Chronos-2 is also highly efficient, delivering over 300 time series forecasts per second on a single A10G GPU and supporting both GPU and CPU inference. Links ☁️ Deploy on SageMaker with AutoGluon-Cloud (recommended) 🚀 Deploy on SageMaker with JumpStart 📄 Technical report 💻 GitHub 📘 Example notebook 📰 Amazon Science Blog Overview 🧩 Chronos & Chronos-Bolt do not natively support future covariates, but they can be combined with external covariate regressors (see AutoGluon tutorial). This only models per-timestep effects, not effects across time. In contrast, Chronos-2 supports all covariate types natively. Running the model locally For experimentation and local inference, you can use the inference package. Make zero-shot predictions using the pandas API Production use on Amazon SageMaker For production use, we recommend deploying Chronos-2 to Amazon SageMaker. There are two options: AutoGluon-Cloud (recommended) — minimal setup with a high-level Python API: pass a pandas DataFrame in, get forecasts back. Supports real-time, serverless, and batch inference out of the box. SageMaker JumpStart — fine-grained control over the deployment configuration. JSON request/response payloads only; serverless inference and batch prediction require additional setup. ☁️ AutoGluon-Cloud Make predictions from a pandas DataFrame For more details (e.g. serverless endpoints, covariate-aware forecasting), see the full deployment guide. 🚀 SageMaker JumpStart First, update the SageMaker SDK to make sure that all the latest models are available. Deploy an inference endpoint to SageMaker. Now you can send time series data to the endpoint in JSON format. For more details about the endpoint API, check out the example notebook. Training data More details about the training data are available in the technical report. Subset of Chronos Datasets (excluding test portion of datasets that overlap with GIFT-Eval) Subset of GIFT-Eval Pretrain Synthetic univariate and multivariate data Citation If you find Chronos-2 useful for your research, please consider citing the associated paper:

google/gemma-4-31B-it

Hugging Face | GitHub | Launch Blog | Documentation | Technical Report License : Apache 2.0 | Authors : Google DeepMind Gemma is a family of open models built by Google DeepMind. Gemma 4 models are multimodal, handling text and image input (with audio supported on E2B, E4B, and 12B) and generating text output. This release includes open-weights models in both pre-trained and instruction-tuned variants. Gemma 4 features a context window of up to 256K tokens and maintains multilingual support in over 140 languages. Featuring both Dense and Mixture-of-Experts (MoE) architectures, Gemma 4 is well-suited for tasks like text generation, coding, and reasoning. The models are available in five distinct sizes: E2B, E4B, 12B, 26B A4B, and 31B. Their diverse sizes make them deployable in environments ranging from high-end phones to laptops and servers, democratizing access to state-of-the-art AI. Gemma 4 introduces key capability and architectural advancements: Reasoning – All models in the family are designed as highly capable reasoners, with configurable thinking modes. Extended Multimodalities – Processes Text, Image with variable aspect ratio and resolution support (all models), Video, and Audio (featured natively on the E2B, E4B, and 12B models). Diverse & Efficient Architectures – Offers Dense and Mixture-of-Experts (MoE) variants of different sizes for scalable deployment. Optimized for On-Device – Smaller models are specifically designed for efficient local execution on laptops and mobile devices. Increased Context Window – The small models feature a 128K context window, while the medium models support 256K. Enhanced Coding & Agentic Capabilities – Achieves notable improvements in coding benchmarks alongside native function-calling support, powering highly capable autonomous agents. Native System Prompt Support – Gemma 4 introduces native support for the system role, enabling more structured and controllable conversations. Models Overview Gemma 4 models are designed to deliver frontier-level performance at each size, targeting deployment scenarios from mobile and edge devices (E2B, E4B) to consumer GPUs and workstations (12B, 26B A4B, 31B). They are well-suited for reasoning, agentic workflows, coding, and multimodal understanding. The models employ a hybrid attention mechanism that interleaves local sliding window attention with full global attention, ensuring the final layer is always global. This hybrid design delivers the processing speed and low memory footprint of a lightweight model without sacrificing the deep awareness required for complex, long-context tasks. To optimize memory for long contexts, global layers feature unified Keys and Values, and apply Proportional RoPE (p-RoPE). Dense Models The "E" in E2B and E4B stands for "effective" parameters. The smaller models incorporate Per-Layer Embeddings (PLE) to maximize parameter efficiency in on-device deployments. Rather than adding more layers or parameters to the model, PLE gives each decoder layer its own small embedding for every token. These embedding tables are large but are only used for quick lookups, which is why the effective parameter count is much smaller than the total. The "Unified" in Gemma 4 12B Unified refers to its encoder-free architecture. Other Gemma 4 models use dedicated encoders to process multimodal data before passing it to the LLM. Gemma 4 12B eliminates these encoders entirely, projecting raw image patches and audio waveforms directly into the LLM's embedding space through lightweight linear layers. This unified approach means all modalities flow straight into a single decoder-only transformer, reducing multimodal latency and allowing the entire model to be fine-tuned in one pass. Mixture-of-Experts (MoE) Model The "A" in 26B A4B stands for "active parameters" in contrast to the total number of parameters the model contains.…

amazon/chronos-bolt-small

🚀 Update Feb 14, 2025: Chronos-Bolt models are now available on Amazon SageMaker JumpStart! Check out the tutorial notebook to learn how to deploy Chronos endpoints for production use in a few lines of code. Chronos-Bolt is a family of pretrained time series forecasting models which can be used for zero-shot forecasting. It is based on the T5 encoder-decoder architecture and has been trained on nearly 100 billion time series observations. It chunks the historical time series context into patches of multiple observations, which are then input into the encoder. The decoder then uses these representations to directly generate quantile forecasts across multiple future steps—a method known as direct multi-step forecasting. Chronos-Bolt models are up to 250 times faster and 20 times more memory-efficient than the original Chronos models of the same size. Performance The following plot compares the inference time of Chronos-Bolt against the original Chronos models for forecasting 1024 time series with a context length of 512 observations and a prediction horizon of 64 steps. Chronos-Bolt models are not only significantly faster but also more accurate than the original Chronos models. The following plot reports the probabilistic and point forecasting performance of Chronos-Bolt in terms of the Weighted Quantile Loss (WQL) and the Mean Absolute Scaled Error (MASE), respectively, aggregated over 27 datasets (see the Chronos paper for details on this benchmark). Remarkably, despite having no prior exposure to these datasets during training, the zero-shot Chronos-Bolt models outperform commonly used statistical models and deep learning models that have been trained on these datasets (highlighted by ). Furthermore, they also perform better than other FMs, denoted by a +, which indicates that these models were pretrained on certain datasets in our benchmark and are not entirely zero-shot. Notably, Chronos-Bolt (Base) also surpasses the original Chronos (Large) model in terms of the forecasting accuracy while being over 600 times faster. Chronos-Bolt models are available in the following sizes. The recommended way of using Chronos for production use cases is through AutoGluon. AutoGluon offers effortless fine-tuning of Chronos models, incorporating covariates into the forecast through covariate regressors, and ensembling with other statistical and machine learning models for maximum accuracy. Check out the AutoGluon Chronos tutorial for more details. A minimal example showing how to perform zero-shot inference using Chronos-Bolt with AutoGluon: Forecast with the Chronos-Bolt model. Deploying a Chronos-Bolt endpoint to SageMaker SageMaker JumpStart makes it easy to deploy Chronos endpoints for production use with just a few lines of code. Chronos-Bolt endpoints can be deployed to both CPU and GPU instances, as well as support forecasting with covariates. More details are available in this example notebook. A minimal example showing how to deploy a Chronos-Bolt (Base) endpoint to SageMaker: Update the SageMaker SDK to make sure that all the latest models are available. Deploy an inference endpoint to SageMaker. Now you can send time series data to the endpoint in JSON format. Usage with inference library Alternatively, you can install the package in the GitHub companion repo. This is intended for research purposes and provides a minimal interface to Chronos models. Install the library by running: A minimal example showing how to perform inference using Chronos-Bolt models: Citation If you find Chronos or Chronos-Bolt models useful for your research, please consider citing the associated paper: License This project is licensed under the Apache-2.0 License.

google/gemma-4-26B-A4B-it

Hugging Face | GitHub | Launch Blog | Documentation | Technical Report License : Apache 2.0 | Authors : Google DeepMind Gemma is a family of open models built by Google DeepMind. Gemma 4 models are multimodal, handling text and image input (with audio supported on E2B, E4B, and 12B) and generating text output. This release includes open-weights models in both pre-trained and instruction-tuned variants. Gemma 4 features a context window of up to 256K tokens and maintains multilingual support in over 140 languages. Featuring both Dense and Mixture-of-Experts (MoE) architectures, Gemma 4 is well-suited for tasks like text generation, coding, and reasoning. The models are available in five distinct sizes: E2B, E4B, 12B, 26B A4B, and 31B. Their diverse sizes make them deployable in environments ranging from high-end phones to laptops and servers, democratizing access to state-of-the-art AI. Gemma 4 introduces key capability and architectural advancements: Reasoning – All models in the family are designed as highly capable reasoners, with configurable thinking modes. Extended Multimodalities – Processes Text, Image with variable aspect ratio and resolution support (all models), Video, and Audio (featured natively on the E2B, E4B, and 12B models). Diverse & Efficient Architectures – Offers Dense and Mixture-of-Experts (MoE) variants of different sizes for scalable deployment. Optimized for On-Device – Smaller models are specifically designed for efficient local execution on laptops and mobile devices. Increased Context Window – The small models feature a 128K context window, while the medium models support 256K. Enhanced Coding & Agentic Capabilities – Achieves notable improvements in coding benchmarks alongside native function-calling support, powering highly capable autonomous agents. Native System Prompt Support – Gemma 4 introduces native support for the system role, enabling more structured and controllable conversations. Models Overview Gemma 4 models are designed to deliver frontier-level performance at each size, targeting deployment scenarios from mobile and edge devices (E2B, E4B) to consumer GPUs and workstations (12B, 26B A4B, 31B). They are well-suited for reasoning, agentic workflows, coding, and multimodal understanding. The models employ a hybrid attention mechanism that interleaves local sliding window attention with full global attention, ensuring the final layer is always global. This hybrid design delivers the processing speed and low memory footprint of a lightweight model without sacrificing the deep awareness required for complex, long-context tasks. To optimize memory for long contexts, global layers feature unified Keys and Values, and apply Proportional RoPE (p-RoPE). Dense Models The "E" in E2B and E4B stands for "effective" parameters. The smaller models incorporate Per-Layer Embeddings (PLE) to maximize parameter efficiency in on-device deployments. Rather than adding more layers or parameters to the model, PLE gives each decoder layer its own small embedding for every token. These embedding tables are large but are only used for quick lookups, which is why the effective parameter count is much smaller than the total. The "Unified" in Gemma 4 12B Unified refers to its encoder-free architecture. Other Gemma 4 models use dedicated encoders to process multimodal data before passing it to the LLM. Gemma 4 12B eliminates these encoders entirely, projecting raw image patches and audio waveforms directly into the LLM's embedding space through lightweight linear layers. This unified approach means all modalities flow straight into a single decoder-only transformer, reducing multimodal latency and allowing the entire model to be fine-tuned in one pass. Mixture-of-Experts (MoE) Model The "A" in 26B A4B stands for "active parameters" in contrast to the total number of parameters the model contains.…

laion/clap-htsat-fused

Model card for CLAP: Contrastive Language-Audio Pretraining Dataset LAION-CLAP was trained on LAION-audio-630k Table of Contents 0. TL;DR 1. Model Details 2. Usage 3. Uses 4. Citation TL;DR The abstract of the paper states that: Contrastive learning has shown remarkable success in the field of multimodal representation learning. In this paper, we propose a pipeline of contrastive language-audio pretraining to develop an audio representation by combining audio data with natural language descriptions. To accomplish this target, we first release LAION-Audio-630K, a large collection of 633,526 audio-text pairs from different data sources. Second, we construct a contrastive language-audio pretraining model by considering different audio encoders and text encoders. We incorporate the feature fusion mechanism and keyword-to-caption augmentation into the model design to further enable the model to process audio inputs of variable lengths and enhance the performance. Third, we perform comprehensive experiments to evaluate our model across three tasks: text-to-audio retrieval, zero-shot audio classification, and supervised audio classification. The results demonstrate that our model achieves superior performance in text-to-audio retrieval task. In audio classification tasks, the model achieves state-of-the-art performance in the zero-shot setting and is able to obtain performance comparable to models' results in the non-zero-shot setting. LAION-Audio-630K and the proposed model are both available to the public. Usage You can use this model for zero shot audio classification or extracting audio and/or textual features. Uses Perform zero-shot audio classification Using pipeline Run the model: You can also get the audio and text embeddings using ClapModel Run the model on CPU: Run the model on GPU: Citation If you are using this model for your work, please consider citing the original paper:

facebook/opt-125m

OPT : Open Pre-trained Transformer Language Models OPT was first introduced in Open Pre-trained Transformer Language Models and first released in metaseq's repository on May 3rd 2022 by Meta AI. Disclaimer: The team releasing OPT wrote an official model card, which is available in Appendix D of the paper. Content from this model card has been written by the Hugging Face team. Intro To quote the first two paragraphs of the official paper Large language models trained on massive text collections have shown surprising emergent capabilities to generate text and perform zero- and few-shot learning. While in some cases the public can interact with these models through paid APIs, full model access is currently limited to only a few highly resourced labs. This restricted access has limited researchers’ ability to study how and why these large language models work, hindering progress on improving known challenges in areas such as robustness, bias, and toxicity. We present Open Pretrained Transformers (OPT), a suite of decoder-only pre-trained transformers ranging from 125M to 175B parameters, which we aim to fully and responsibly share with interested researchers. We train the OPT models to roughly match the performance and sizes of the GPT-3 class of models, while also applying the latest best practices in data collection and efficient training. Our aim in developing this suite of OPT models is to enable reproducible and responsible research at scale, and to bring more voices to the table in studying the impact of these LLMs. Definitions of risk, harm, bias, and toxicity, etc., should be articulated by the collective research community as a whole, which is only possible when models are available for study. Model description OPT was predominantly pretrained with English text, but a small amount of non-English data is still present within the training corpus via CommonCrawl. The model was pretrained using a causal language modeling (CLM) objective. OPT belongs to the same family of decoder-only models like GPT-3. As such, it was pretrained using the self-supervised causal language modedling objective. For evaluation, OPT follows GPT-3 by using their prompts and overall experimental setup. For more details, please read the official paper. Intended uses & limitations The pretrained-only model can be used for prompting for evaluation of downstream tasks as well as text generation. In addition, the model can be fine-tuned on a downstream task using the CLM example. For all other OPT checkpoints, please have a look at the model hub. How to use You can use this model directly with a pipeline for text generation. By default, generation is deterministic. In order to use the top-k sampling, please set dosample to True. Limitations and bias As mentioned in Meta AI's model card, given that the training data used for this model contains a lot of unfiltered content from the internet, which is far from neutral the model is strongly biased : Like other large language models for which the diversity (or lack thereof) of training data induces downstream impact on the quality of our model, OPT-175B has limitations in terms of bias and safety. OPT-175B can also have quality issues in terms of generation diversity and hallucination. In general, OPT-175B is not immune from the plethora of issues that plague modern large language models. This bias will also affect all fine-tuned versions of this model. Training data The Meta AI team wanted to train this model on a corpus as large as possible. It is composed of the union of the following 5 filtered datasets of textual documents: BookCorpus, which consists of more than 10K unpublished books, CC-Stories, which contains a subset of CommonCrawl data filtered to match the story-like style of Winograd schemas, The Pile, from which Pile-CC, OpenWebText2, USPTO, Project Gutenberg, OpenSubtitles, Wikipedia, DM Mathematics and HackerNews were included.…

facebook/contriever

This model has been trained without supervision following the approach described in Towards Unsupervised Dense Information Retrieval with Contrastive Learning. The associated GitHub repository is available here https://github.com/facebookresearch/contriever. Usage (HuggingFace Transformers) Using the model directly available in HuggingFace transformers requires to add a mean pooling operation to obtain a sentence embedding.

FacebookAI/roberta-base

Pretrained model on English language using a masked language modeling (MLM) objective. It was introduced in this paper and first released in this repository. This model is case-sensitive: it makes a difference between english and English. Disclaimer: The team releasing RoBERTa did not write a model card for this model so this model card has been written by the Hugging Face team. Model description RoBERTa is a transformers model pretrained on a large corpus of English data in a self-supervised fashion. This means it was pretrained on the raw texts only, with no humans labelling them in any way (which is why it can use lots of publicly available data) with an automatic process to generate inputs and labels from those texts. More precisely, it was pretrained with the Masked language modeling (MLM) objective. Taking a sentence, the model randomly masks 15% of the words in the input then run the entire masked sentence through the model and has to predict the masked words. This is different from traditional recurrent neural networks (RNNs) that usually see the words one after the other, or from autoregressive models like GPT which internally mask the future tokens. It allows the model to learn a bidirectional representation of the sentence. This way, the model learns an inner representation of the English language that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled sentences for instance, you can train a standard classifier using the features produced by the BERT model as inputs. Intended uses & limitations You can use the raw model for masked language modeling, but it's mostly intended to be fine-tuned on a downstream task. See the model hub to look for fine-tuned versions on a task that interests you. Note that this model is primarily aimed at being fine-tuned on tasks that use the whole sentence (potentially masked) to make decisions, such as sequence classification, token classification or question answering. For tasks such as text generation you should look at a model like GPT2. How to use You can use this model directly with a pipeline for masked language modeling: Here is how to use this model to get the features of a given text in PyTorch: The training data used for this model contains a lot of unfiltered content from the internet, which is far from neutral. Therefore, the model can have biased predictions: This bias will also affect all fine-tuned versions of this model. Training data The RoBERTa model was pretrained on the reunion of five datasets: BookCorpus, a dataset consisting of 11,038 unpublished books; English Wikipedia (excluding lists, tables and headers) ; CC-News, a dataset containing 63 millions English news articles crawled between September 2016 and February 2019. OpenWebText, an opensource recreation of the WebText dataset used to train GPT-2, Stories a dataset containing a subset of CommonCrawl data filtered to match the story-like style of Winograd schemas. Together these datasets weigh 160GB of text. Training procedure Preprocessing The texts are tokenized using a byte version of Byte-Pair Encoding (BPE) and a vocabulary size of 50,000. The inputs of the model take pieces of 512 contiguous tokens that may span over documents. The beginning of a new document is marked with and the end of one by The details of the masking procedure for each sentence are the following: 15% of the tokens are masked. In 80% of the cases, the masked tokens are replaced by . In 10% of the cases, the masked tokens are replaced by a random token (different) from the one they replace. In the 10% remaining cases, the masked tokens are left as is. Contrary to BERT, the masking is done dynamically during pretraining (e.g., it changes at each epoch and is not fixed). Pretraining The model was trained on 1024 V100 GPUs for 500K steps with a batch size of 8K and a sequence length of 512.…

Qwen/Qwen2.5-VL-7B-Instruct

--- license: apache-2.0 language: en pipelinetag: image-text-to-text tags: multimodal libraryname: transformers --- Qwen2.5-VL-7B-Instruct Introduction In the past five months since Qwen2-VL’s release, numerous developers have built new models on the Qwen2-VL vision-language models, providing us with valuable feedback. During this period, we focused on building more useful vision-language models. Today, we are excited to introduce the latest addition to the Qwen family: Qwen2.5-VL. Key Enhancements: Understand things visually: Qwen2.5-VL is not only proficient in recognizing common objects such as flowers, birds, fish, and insects, but it is highly capable of analyzing texts, charts, icons, graphics, and layouts within images. Being agentic: Qwen2.5-VL directly plays as a visual agent that can reason and dynamically direct tools, which is capable of computer use and phone use. Understanding long videos and capturing events: Qwen2.5-VL can comprehend videos of over 1 hour, and this time it has a new ability of cpaturing event by pinpointing the relevant video segments. Capable of visual localization in different formats: Qwen2.5-VL can accurately localize objects in an image by generating bounding boxes or points, and it can provide stable JSON outputs for coordinates and attributes. Generating structured outputs: for data like scans of invoices, forms, tables, etc. Qwen2.5-VL supports structured outputs of their contents, benefiting usages in finance, commerce, etc. Model Architecture Updates: Dynamic Resolution and Frame Rate Training for Video Understanding: We extend dynamic resolution to the temporal dimension by adopting dynamic FPS sampling, enabling the model to comprehend videos at various sampling rates. Accordingly, we update mRoPE in the time dimension with IDs and absolute time alignment, enabling the model to learn temporal sequence and speed, and ultimately acquire the ability to pinpoint specific moments. Streamlined and Efficient Vision Encoder We enhance both training and inference speeds by strategically implementing window attention into the ViT. The ViT architecture is further optimized with SwiGLU and RMSNorm, aligning it with the structure of the Qwen2.5 LLM. We have three models with 3, 7 and 72 billion parameters. This repo contains the instruction-tuned 7B Qwen2.5-VL model. For more information, visit our Blog and GitHub. Evaluation Image benchmark Requirements The code of Qwen2.5-VL has been in the latest Hugging face transformers and we advise you to build from source with command: or you might encounter the following error: Quickstart Below, we provide simple examples to show how to use Qwen2.5-VL with 🤖 ModelScope and 🤗 Transformers. The code of Qwen2.5-VL has been in the latest Hugging face transformers and we advise you to build from source with command: or you might encounter the following error: We offer a toolkit to help you handle various types of visual input more conveniently, as if you were using an API. This includes base64, URLs, and interleaved images and videos. You can install it using the following command: If you are not using Linux, you might not be able to install decord from PyPI. In that case, you can use pip install qwen-vl-utils which will fall back to using torchvision for video processing. However, you can still install decord from source to get decord used when loading video. Using 🤗 Transformers to Chat Here we show a code snippet to show you how to use the chat model with transformers and qwenvlutils: Video URL compatibility largely depends on the third-party library version. The details are in the table below. change the backend by FORCEQWENVLVIDEOREADER=torchvision or FORCEQWENVLVIDEOREADER=decord if you prefer not to use the default one. Batch inference 🤖 ModelScope We strongly advise users especially those in mainland China to use ModelScope. snapshotdownload can help you solve issues concerning downloading checkpoints. More Usage Tips…

openai/clip-vit-large-patch14

Disclaimer: The model card is taken and modified from the official CLIP repository, it can be found here. Model Details The CLIP model was developed by researchers at OpenAI to learn about what contributes to robustness in computer vision tasks. The model was also developed to test the ability of models to generalize to arbitrary image classification tasks in a zero-shot manner. It was not developed for general model deployment - to deploy models like CLIP, researchers will first need to carefully study their capabilities in relation to the specific context they’re being deployed within. Model Date The base model uses a ViT-L/14 Transformer architecture as an image encoder and uses a masked self-attention Transformer as a text encoder. These encoders are trained to maximize the similarity of (image, text) pairs via a contrastive loss. The original implementation had two variants: one using a ResNet image encoder and the other using a Vision Transformer. This repository has the variant with the Vision Transformer. Documents Blog Post CLIP Paper Use with Transformers Model Use Intended Use The model is intended as a research output for research communities. We hope that this model will enable researchers to better understand and explore zero-shot, arbitrary image classification. We also hope it can be used for interdisciplinary studies of the potential impact of such models - the CLIP paper includes a discussion of potential downstream impacts to provide an example for this sort of analysis. Primary intended uses The primary intended users of these models are AI researchers. We primarily imagine the model will be used by researchers to better understand robustness, generalization, and other capabilities, biases, and constraints of computer vision models. Out-of-Scope Use Cases Any deployed use case of the model - whether commercial or not - is currently out of scope. Non-deployed use cases such as image search in a constrained environment, are also not recommended unless there is thorough in-domain testing of the model with a specific, fixed class taxonomy. This is because our safety assessment demonstrated a high need for task specific testing especially given the variability of CLIP’s performance with different class taxonomies. This makes untested and unconstrained deployment of the model in any use case currently potentially harmful. Certain use cases which would fall under the domain of surveillance and facial recognition are always out-of-scope regardless of performance of the model. This is because the use of artificial intelligence for tasks such as these can be premature currently given the lack of testing norms and checks to ensure its fair use. Since the model has not been purposefully trained in or evaluated on any languages other than English, its use should be limited to English language use cases. Data The model was trained on publicly available image-caption data. This was done through a combination of crawling a handful of websites and using commonly-used pre-existing image datasets such as YFCC100M. A large portion of the data comes from our crawling of the internet. This means that the data is more representative of people and societies most connected to the internet which tend to skew towards more developed nations, and younger, male users. Data Mission Statement Our goal with building this dataset was to test out robustness and generalizability in computer vision tasks. As a result, the focus was on gathering large quantities of data from different publicly-available internet data sources. The data was gathered in a mostly non-interventionist manner. However, we only crawled websites that had policies against excessively violent and adult images and allowed us to filter out such content. We do not intend for this dataset to be used as the basis for any commercial or deployed model and will not be releasing the dataset. Performance and Limitations Performance…