Datasets:

rbiswasfc

/

gorilla-bench-apis

like 0

Natural Language Processing Feature Extraction

Hugging Face Transformers

Feature Extraction

YituTech/conv-bert-base

AutoModel.from_pretrained('YituTech/conv-bert-base')

N/A

transformers

N/A

{'dataset': 'N/A', 'accuracy': 'N/A'}

A pre-trained ConvBERT model for feature extraction provided by YituTech, based on the Hugging Face Transformers library.

Natural Language Processing Feature Extraction

Hugging Face Transformers

Feature Extraction

dmis-lab/biobert-v1.1

AutoModel.from_pretrained('dmis-lab/biobert-v1.1')

[]

['transformers']

{'dataset': '', 'accuracy': ''}

BioBERT is a pre-trained biomedical language representation model for biomedical text mining tasks such as biomedical named entity recognition, relation extraction, and question answering.

Natural Language Processing Sentence Similarity

Hugging Face Transformers

Feature Extraction

princeton-nlp/unsup-simcse-roberta-base

AutoModel.from_pretrained('princeton-nlp/unsup-simcse-roberta-base')

None

['transformers']

None

{'dataset': None, 'accuracy': None}

An unsupervised sentence embedding model trained using the SimCSE approach with a Roberta base architecture.

Multimodal Feature Extraction

Hugging Face Transformers

Feature Extraction

cambridgeltl/SapBERT-from-PubMedBERT-fulltext

AutoModel.from_pretrained('cambridgeltl/SapBERT-from-PubMedBERT-fulltext')

input_ids, attention_mask

transformers

inputs = tokenizer('covid infection', return_tensors='pt'); outputs = model(**inputs); cls_embedding = outputs.last_hidden_state[:, 0, :]

{'dataset': 'UMLS', 'accuracy': 'N/A'}

SapBERT is a pretraining scheme that self-aligns the representation space of biomedical entities. It is trained with UMLS 2020AA (English only) and uses microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract-fulltext as the base model. The input should be a string of biomedical entity names, and the [CLS] embedding of the last layer is regarded as the output.

Natural Language Processing Text Generation

Hugging Face Transformers

Feature Extraction

facebook/bart-base

BartModel.from_pretrained('facebook/bart-base')

['inputs']

['transformers']

from transformers import BartTokenizer, BartModel tokenizer = BartTokenizer.from_pretrained('facebook/bart-base') model = BartModel.from_pretrained('facebook/bart-base') inputs = tokenizer(Hello, my dog is cute, return_tensors=pt) outputs = model(**inputs) last_hidden_states = outputs.last_hidden_state

{'dataset': 'arxiv', 'accuracy': 'Not provided'}

BART is a transformer encoder-decoder (seq2seq) model with a bidirectional (BERT-like) encoder and an autoregressive (GPT-like) decoder. BART is pre-trained by (1) corrupting text with an arbitrary noising function, and (2) learning a model to reconstruct the original text. BART is particularly effective when fine-tuned for text generation (e.g. summarization, translation) but also works well for comprehension tasks (e.g. text classification, question answering).

Natural Language Processing Text Generation

Hugging Face Transformers

Feature Extraction

facebook/bart-large

BartModel.from_pretrained('facebook/bart-large')

{'pretrained_model_name': 'facebook/bart-large'}

{'library': 'transformers', 'version': 'latest'}

from transformers import BartTokenizer, BartModel tokenizer = BartTokenizer.from_pretrained('facebook/bart-large') model = BartModel.from_pretrained('facebook/bart-large') inputs = tokenizer(Hello, my dog is cute, return_tensors=pt) outputs = model(**inputs) last_hidden_states = outputs.last_hidden_state

{'dataset': 'arxiv', 'accuracy': 'Not provided'}

BART is a transformer encoder-decoder (seq2seq) model with a bidirectional (BERT-like) encoder and an autoregressive (GPT-like) decoder. BART is pre-trained by (1) corrupting text with an arbitrary noising function, and (2) learning a model to reconstruct the original text. BART is particularly effective when fine-tuned for text generation (e.g. summarization, translation) but also works well for comprehension tasks (e.g. text classification, question answering).

Computer Vision Image Classification

Hugging Face Transformers

Feature Extraction

facebook/dino-vits8

ViTModel.from_pretrained('facebook/dino-vits8')

['images', 'return_tensors']

['transformers', 'PIL', 'requests']

from transformers import ViTFeatureExtractor, ViTModel from PIL import Image import requests url = 'http://images.cocodataset.org/val2017/000000039769.jpg' image = Image.open(requests.get(url, stream=True).raw) feature_extractor = ViTFeatureExtractor.from_pretrained('facebook/dino-vits8') model = ViTModel.from_pretrained('facebook/dino-vits8') inputs = feature_extractor(images=image, return_tensors=pt) outputs = model(**inputs) last_hidden_states = outputs.last_hidden_state

{'dataset': 'imagenet-1k', 'accuracy': None}

Vision Transformer (ViT) model trained using the DINO method. It was introduced in the paper Emerging Properties in Self-Supervised Vision Transformers by Mathilde Caron, Hugo Touvron, Ishan Misra, Hervé Jégou, Julien Mairal, Piotr Bojanowski, Armand Joulin and first released in this repository.

Computer Vision Image Classification

Hugging Face Transformers

Feature Extraction

facebook/dino-vitb16

ViTModel.from_pretrained('facebook/dino-vitb16')

{'pretrained_model_name_or_path': 'facebook/dino-vitb16'}

{'transformers': 'latest', 'PIL': 'latest', 'requests': 'latest'}

from transformers import ViTFeatureExtractor, ViTModel from PIL import Image import requests url = 'http://images.cocodataset.org/val2017/000000039769.jpg' image = Image.open(requests.get(url, stream=True).raw) feature_extractor = ViTFeatureExtractor.from_pretrained('facebook/dino-vitb16') model = ViTModel.from_pretrained('facebook/dino-vitb16') inputs = feature_extractor(images=image, return_tensors=pt) outputs = model(**inputs) last_hidden_states = outputs.last_hidden_state

{'dataset': 'imagenet-1k', 'accuracy': 'Not provided'}

Vision Transformer (ViT) model trained using the DINO method. The model is pretrained on a large collection of images in a self-supervised fashion, namely ImageNet-1k, at a resolution of 224x224 pixels. Images are presented to the model as a sequence of fixed-size patches (resolution 16x16), which are linearly embedded. One also adds a [CLS] token to the beginning of a sequence to use it for classification tasks. One also adds absolute position embeddings before feeding the sequence to the layers of the Transformer encoder. Note that this model does not include any fine-tuned heads.

Natural Language Processing Feature Extraction

PyTorch Transformers

Feature Extraction

kobart-base-v2

BartModel.from_pretrained('gogamza/kobart-base-v2')

{'tokenizer': "PreTrainedTokenizerFast.from_pretrained('gogamza/kobart-base-v2')"}

{'transformers': 'latest', 'tokenizers': 'latest'}

from transformers import PreTrainedTokenizerFast, BartModel tokenizer = PreTrainedTokenizerFast.from_pretrained('gogamza/kobart-base-v2') model = BartModel.from_pretrained('gogamza/kobart-base-v2')

{'dataset': 'NSMC', 'accuracy': 0.901}

KoBART is a Korean encoder-decoder language model trained on over 40GB of Korean text using the BART architecture. It can be used for feature extraction and has been trained on a variety of data sources, including Korean Wiki, news, books, and more.

Natural Language Processing Feature Extraction

Hugging Face Transformers

Contextual Representation

indobenchmark/indobert-base-p1

AutoModel.from_pretrained('indobenchmark/indobert-base-p1')

['BertTokenizer', 'AutoModel', 'tokenizer.encode', 'torch.LongTensor', 'model(x)[0].sum()']

['transformers', 'torch']

from transformers import BertTokenizer, AutoModel tokenizer = BertTokenizer.from_pretrained('indobenchmark/indobert-base-p1') model = AutoModel.from_pretrained('indobenchmark/indobert-base-p1') x = torch.LongTensor(tokenizer.encode('aku adalah anak [MASK]')).view(1,-1) print(x, model(x)[0].sum())

{'dataset': 'Indo4B', 'accuracy': '23.43 GB of text'}

IndoBERT is a state-of-the-art language model for Indonesian based on the BERT model. The pretrained model is trained using a masked language modeling (MLM) objective and next sentence prediction (NSP) objective.

Multimodal Feature Extraction

Hugging Face Transformers

Feature Extraction

microsoft/codebert-base

AutoModel.from_pretrained('microsoft/codebert-base')

n/a

['transformers']

n/a

{'dataset': 'CodeSearchNet', 'accuracy': 'n/a'}

Pretrained weights for CodeBERT: A Pre-Trained Model for Programming and Natural Languages. The model is trained on bi-modal data (documents & code) of CodeSearchNet. This model is initialized with Roberta-base and trained with MLM+RTD objective.

Multimodal Feature Extraction

Hugging Face Transformers

Feature Extraction

GanjinZero/UMLSBert_ENG

AutoModel.from_pretrained('GanjinZero/UMLSBert_ENG')

[]

['transformers']

{'dataset': '', 'accuracy': ''}

CODER: Knowledge infused cross-lingual medical term embedding for term normalization. English Version. Old name. This model is not UMLSBert! Github Link: https://github.com/GanjinZero/CODER

Multimodal Feature Extraction

Hugging Face Transformers

Feature Extraction

hubert-large-ll60k

HubertModel.from_pretrained('facebook/hubert-large-ll60k')

pretrained model name

transformers

hubert = HubertModel.from_pretrained('facebook/hubert-large-ll60k')

{'dataset': 'Libri-Light', 'accuracy': 'matches or improves upon the state-of-the-art wav2vec 2.0 performance'}

Hubert-Large is a self-supervised speech representation learning model pretrained on 16kHz sampled speech audio. It is designed to deal with the unique problems in speech representation learning, such as multiple sound units in each input utterance, no lexicon of input sound units during the pre-training phase, and variable lengths of sound units with no explicit segmentation. The model relies on an offline clustering step to provide aligned target labels for a BERT-like prediction loss.

Natural Language Processing Feature Extraction

Hugging Face Transformers

Feature Extraction

sup-simcse-roberta-large

AutoModel.from_pretrained('princeton-nlp/sup-simcse-roberta-large')

['AutoTokenizer', 'AutoModel']

['transformers']

from transformers import AutoTokenizer, AutoModel tokenizer = AutoTokenizer.from_pretrained(princeton-nlp/sup-simcse-roberta-large) model = AutoModel.from_pretrained(princeton-nlp/sup-simcse-roberta-large)

{'dataset': 'STS tasks', 'accuracy': "Spearman's correlation (See associated paper Appendix B)"}

A pretrained RoBERTa-large model for simple contrastive learning of sentence embeddings. It can be used for feature extraction and has been evaluated on semantic textual similarity (STS) tasks and downstream transfer tasks.

Natural Language Processing Text Generation

Hugging Face Transformers

Transformers

lewtun/tiny-random-mt5

AutoModel.from_pretrained('lewtun/tiny-random-mt5')

text

transformers

nlp('Once upon a time...')

{'dataset': '', 'accuracy': ''}

A tiny random mt5 model for text generation

Multimodal Feature Extraction

Hugging Face Transformers

Feature Extraction

DeepPavlov/rubert-base-cased

AutoModel.from_pretrained('DeepPavlov/rubert-base-cased')

[]

['transformers']

{'dataset': 'Russian part of Wikipedia and news data', 'accuracy': ''}

RuBERT (Russian, cased, 12‑layer, 768‑hidden, 12‑heads, 180M parameters) was trained on the Russian part of Wikipedia and news data. We used this training data to build a vocabulary of Russian subtokens and took a multilingual version of BERT‑base as an initialization for RuBERT[1].

Audio Automatic Speech Recognition

Hugging Face Transformers

Feature Extraction

microsoft/wavlm-large

Wav2Vec2Model.from_pretrained('microsoft/wavlm-large')

speech input

transformers

To fine-tune the model for speech recognition, see the official speech recognition example. To fine-tune the model for speech classification, see the official audio classification example.

{'dataset': 'SUPERB benchmark', 'accuracy': 'state-of-the-art performance'}

WavLM-Large is a large model pretrained on 16kHz sampled speech audio. It is built based on the HuBERT framework, with an emphasis on both spoken content modeling and speaker identity preservation. WavLM is pretrained on 60,000 hours of Libri-Light, 10,000 hours of GigaSpeech, and 24,000 hours of VoxPopuli. It achieves state-of-the-art performance on the SUPERB benchmark and brings significant improvements for various speech processing tasks on their representative benchmarks.

Computer Vision Image Classification

Hugging Face Transformers

Feature Extraction

google/vit-base-patch16-224-in21k

ViTModel.from_pretrained('google/vit-base-patch16-224-in21k')

{'pretrained_model_name_or_path': 'google/vit-base-patch16-224-in21k'}

['transformers', 'PIL', 'requests']

from transformers import ViTImageProcessor, ViTModel from PIL import Image import requests url = 'http://images.cocodataset.org/val2017/000000039769.jpg' image = Image.open(requests.get(url, stream=True).raw) processor = ViTImageProcessor.from_pretrained('google/vit-base-patch16-224-in21k') model = ViTModel.from_pretrained('google/vit-base-patch16-224-in21k') inputs = processor(images=image, return_tensors=pt) outputs = model(**inputs) last_hidden_states = outputs.last_hidden_state

{'dataset': 'ImageNet-21k', 'accuracy': 'Refer to tables 2 and 5 of the original paper'}

The Vision Transformer (ViT) is a transformer encoder model (BERT-like) pretrained on ImageNet-21k (14 million images, 21,843 classes) at resolution 224x224. It was introduced in the paper An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale by Dosovitskiy et al. and first released in this repository. However, the weights were converted from the timm repository by Ross Wightman, who already converted the weights from JAX to PyTorch. Credits go to him.

Multimodal Feature Extraction

Hugging Face Transformers

Feature Engineering

microsoft/unixcoder-base

AutoModel.from_pretrained('microsoft/unixcoder-base')

{'tokenizer': "AutoTokenizer.from_pretrained('microsoft/unixcoder-base')"}

{'transformers': 'from transformers import AutoTokenizer, AutoModel'}

tokenizer = AutoTokenizer.from_pretrained('microsoft/unixcoder-base') model = AutoModel.from_pretrained('microsoft/unixcoder-base')

{'dataset': 'Not specified', 'accuracy': 'Not specified'}

UniXcoder is a unified cross-modal pre-trained model that leverages multimodal data (i.e. code comment and AST) to pretrain code representation. Developed by Microsoft Team and shared by Hugging Face. It is based on the RoBERTa model and trained on English language data. The model can be used for feature engineering tasks.

Natural Language Processing Question Answering

Transformers

Feature Extraction

facebook/dpr-question_encoder-single-nq-base

DPRQuestionEncoder.from_pretrained('facebook/dpr-question_encoder-single-nq-base')

['input_ids']

['transformers']

from transformers import DPRQuestionEncoder, DPRQuestionEncoderTokenizer tokenizer = DPRQuestionEncoderTokenizer.from_pretrained(facebook/dpr-question_encoder-single-nq-base) model = DPRQuestionEncoder.from_pretrained(facebook/dpr-question_encoder-single-nq-base) input_ids = tokenizer(Hello, is my dog cute ?, return_tensors=pt)[input_ids] embeddings = model(input_ids).pooler_output

{'dataset': [{'name': 'NQ', 'accuracy': {'top_20': 78.4, 'top_100': 85.4}}, {'name': 'TriviaQA', 'accuracy': {'top_20': 79.4, 'top_100': 85.0}}, {'name': 'WQ', 'accuracy': {'top_20': 73.2, 'top_100': 81.4}}, {'name': 'TREC', 'accuracy': {'top_20': 79.8, 'top_100': 89.1}}, {'name': 'SQuAD', 'accuracy': {'top_20': 63.2, 'top_100': 77.2}}]}

Dense Passage Retrieval (DPR) is a set of tools and models for state-of-the-art open-domain Q&A research. dpr-question_encoder-single-nq-base is the question encoder trained using the Natural Questions (NQ) dataset (Lee et al., 2019; Kwiatkowski et al., 2019).

Multimodal Feature Extraction

Hugging Face Transformers

Audio Spectrogram

audio-spectrogram-transformer

ASTModel.from_pretrained('MIT/ast-finetuned-audioset-10-10-0.4593')

transformers

{'dataset': '', 'accuracy': ''}

One custom ast model for testing of HF repos

Multimodal Feature Extraction

Hugging Face Transformers

Feature Extraction

rasa/LaBSE

AutoModel.from_pretrained('rasa/LaBSE')

input_text

['transformers']

{'dataset': '', 'accuracy': ''}

LaBSE (Language-agnostic BERT Sentence Embedding) model for extracting sentence embeddings in multiple languages.

Natural Language Processing Sentence Similarity

Hugging Face Transformers

Feature Extraction

sentence-transformers/distilbert-base-nli-mean-tokens

SentenceTransformer('sentence-transformers/distilbert-base-nli-mean-tokens')

['sentences']

pip install -U sentence-transformers

from sentence_transformers import SentenceTransformer sentences = [This is an example sentence, Each sentence is converted] model = SentenceTransformer('sentence-transformers/distilbert-base-nli-mean-tokens') embeddings = model.encode(sentences) print(embeddings)

{'dataset': 'https://seb.sbert.net', 'accuracy': 'Not provided'}

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.

Natural Language Processing Feature Extraction

Hugging Face Transformers

Document-level embeddings of research papers

malteos/scincl

AutoModel.from_pretrained('malteos/scincl')

{'tokenizer': "AutoTokenizer.from_pretrained('malteos/scincl')", 'model': "AutoModel.from_pretrained('malteos/scincl')"}

{'transformers': '4.13.0'}

from transformers import AutoTokenizer, AutoModel tokenizer = AutoTokenizer.from_pretrained('malteos/scincl') model = AutoModel.from_pretrained('malteos/scincl') papers = [{'title': 'BERT', 'abstract': 'We introduce a new language representation model called BERT'}, {'title': 'Attention is all you need', 'abstract': ' The dominant sequence transduction models are based on complex recurrent or convolutional neural networks'}] title_abs = [d['title'] + tokenizer.sep_token + (d.get('abstract') or '') for d in papers] inputs = tokenizer(title_abs, padding=True, truncation=True, return_tensors=pt, max_length=512) result = model(**inputs) embeddings = result.last_hidden_state[:, 0, :]

{'dataset': 'SciDocs', 'accuracy': {'mag-f1': 81.2, 'mesh-f1': 89.0, 'co-view-map': 85.3, 'co-view-ndcg': 92.2, 'co-read-map': 87.7, 'co-read-ndcg': 94.0, 'cite-map': 93.6, 'cite-ndcg': 97.4, 'cocite-map': 91.7, 'cocite-ndcg': 96.5, 'recomm-ndcg': 54.3, 'recomm-P@1': 19.6}}

SciNCL is a pre-trained BERT language model to generate document-level embeddings of research papers. It uses the citation graph neighborhood to generate samples for contrastive learning. Prior to the contrastive training, the model is initialized with weights from scibert-scivocab-uncased. The underlying citation embeddings are trained on the S2ORC citation graph.

Natural Language Processing Text Generation

Hugging Face Transformers

Feature Extraction

sberbank-ai/sbert_large_mt_nlu_ru

AutoModel.from_pretrained('sberbank-ai/sbert_large_mt_nlu_ru')

['sentences', 'padding', 'truncation', 'max_length', 'return_tensors']

['transformers', 'torch']

from transformers import AutoTokenizer, AutoModel import torch # Mean Pooling - Take attention mask into account for correct averaging def mean_pooling(model_output, attention_mask): token_embeddings = model_output[0] # First element of model_output contains all token embeddings input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float() sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, 1) sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9) return sum_embeddings / sum_mask # Sentences we want sentence embeddings for sentences = ['?'] # Load AutoModel from huggingface model repository tokenizer = AutoTokenizer.from_pretrained(sberbank-ai/sbert_large_mt_nlu_ru) model = AutoModel.from_pretrained(sberbank-ai/sbert_large_mt_nlu_ru) # Tokenize sentences encoded_input = tokenizer(sentences, padding=True, truncation=True, max_length=24, return_tensors='pt') # Compute token embeddings with torch.no_grad(): model_output = model(**encoded_input) # Perform pooling. In this case, mean pooling sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])

{'dataset': 'Russian SuperGLUE', 'accuracy': 'Not provided'}

BERT large model multitask (cased) for Sentence Embeddings in Russian language.

Natural Language Processing Sentence Similarity

Hugging Face Transformers

Feature Extraction

setu4993/LaBSE

BertModel.from_pretrained('setu4993/LaBSE')

['english_sentences', 'italian_sentences', 'japanese_sentences']

['torch', 'transformers']

import torch from transformers import BertModel, BertTokenizerFast tokenizer = BertTokenizerFast.from_pretrained('setu4993/LaBSE') model = BertModel.from_pretrained('setu4993/LaBSE') model = model.eval() english_sentences = [ 'dog', 'Puppies are nice.', 'I enjoy taking long walks along the beach with my dog.', ] english_inputs = tokenizer(english_sentences, return_tensors='pt', padding=True) with torch.no_grad(): english_outputs = model(**english_inputs) english_embeddings = english_outputs.pooler_output

{'dataset': 'CommonCrawl and Wikipedia', 'accuracy': 'Not Specified'}

Language-agnostic BERT Sentence Encoder (LaBSE) is a BERT-based model trained for sentence embedding for 109 languages. The pre-training process combines masked language modeling with translation language modeling. The model is useful for getting multilingual sentence embeddings and for bi-text retrieval.

Natural Language Processing Token Classification

Hugging Face Transformers

Feature Extraction

lanwuwei/BERTOverflow_stackoverflow_github

AutoModelForTokenClassification.from_pretrained('lanwuwei/BERTOverflow_stackoverflow_github')

{'pretrained_model_name_or_path': 'lanwuwei/BERTOverflow_stackoverflow_github'}

{'transformers': '*', 'torch': '*'}

from transformers import * import torch tokenizer = AutoTokenizer.from_pretrained(lanwuwei/BERTOverflow_stackoverflow_github) model = AutoModelForTokenClassification.from_pretrained(lanwuwei/BERTOverflow_stackoverflow_github)

{'dataset': "StackOverflow's 10 year archive", 'accuracy': 'Not provided'}

BERT-base model pre-trained on 152 million sentences from the StackOverflow's 10 year archive. It can be used for code and named entity recognition in StackOverflow.

Computer Vision Video Classification

Hugging Face Transformers

Feature Extraction

microsoft/xclip-base-patch16-zero-shot

XClipModel.from_pretrained('microsoft/xclip-base-patch16-zero-shot')

[]

['transformers']

For code examples, we refer to the documentation.

{'dataset': [{'name': 'HMDB-51', 'accuracy': 44.6}, {'name': 'UCF-101', 'accuracy': 72.0}, {'name': 'Kinetics-600', 'accuracy': 65.2}]}

X-CLIP is a minimal extension of CLIP for general video-language understanding. The model is trained in a contrastive way on (video, text) pairs. This allows the model to be used for tasks like zero-shot, few-shot or fully supervised video classification and video-text retrieval.

Multimodal Text-to-Image

Hugging Face

Text-to-Image Generation

runwayml/stable-diffusion-v1-5

StableDiffusionPipeline.from_pretrained(runwayml/stable-diffusion-v1-5, torch_dtype=torch.float16)

{'prompt': 'a photo of an astronaut riding a horse on mars'}

{'diffusers': 'from diffusers import StableDiffusionPipeline', 'torch': 'import torch'}

{'model_id': 'model_id = runwayml/stable-diffusion-v1-5', 'pipe': 'pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)', 'pipe_to_cuda': 'pipe = pipe.to(cuda)', 'prompt': 'prompt = a photo of an astronaut riding a horse on mars', 'image': 'image = pipe(prompt).images[0]', 'save_image': 'image.save(astronaut_rides_horse.png)'}

{'dataset': 'COCO2017', 'accuracy': 'Not optimized for FID scores'}

Stable Diffusion is a latent text-to-image diffusion model capable of generating photo-realistic images given any text input.

Multimodal Feature Extraction

Hugging Face Transformers

Transformers

facebook/dragon-plus-context-encoder

AutoModel.from_pretrained('facebook/dragon-plus-context-encoder')

['pretrained']

['torch', 'transformers']

import torch from transformers import AutoTokenizer, AutoModel tokenizer = AutoTokenizer.from_pretrained('facebook/dragon-plus-query-encoder') query_encoder = AutoModel.from_pretrained('facebook/dragon-plus-query-encoder') context_encoder = AutoModel.from_pretrained('facebook/dragon-plus-context-encoder') query = 'Where was Marie Curie born?' contexts = [ 'Maria Sklodowska, later known as Marie Curie, was born on November 7, 1867.', 'Born in Paris on 15 May 1859, Pierre Curie was the son of Eugène Curie, a doctor of French Catholic origin from Alsace.' ] query_input = tokenizer(query, return_tensors='pt') ctx_input = tokenizer(contexts, padding=True, truncation=True, return_tensors='pt') query_emb = query_encoder(query_input).last_hidden_state[:, 0, :] ctx_emb = context_encoder(ctx_input).last_hidden_state[:, 0, :] score1 = query_emb @ ctx_emb[0] score2 = query_emb @ ctx_emb[1]

{'dataset': 'MS MARCO', 'accuracy': 39.0}

DRAGON+ is a BERT-base sized dense retriever initialized from RetroMAE and further trained on the data augmented from MS MARCO corpus, following the approach described in How to Train Your DRAGON: Diverse Augmentation Towards Generalizable Dense Retrieval. The associated GitHub repository is available here https://github.com/facebookresearch/dpr-scale/tree/main/dragon. We use asymmetric dual encoder, with two distinctly parameterized encoders.

Multimodal Text-to-Image

Hugging Face

Text-to-Image Generation

CompVis/stable-diffusion-v1-4

StableDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4')

['prompt']

['diffusers', 'transformers', 'scipy']

import torch from diffusers import StableDiffusionPipeline model_id = CompVis/stable-diffusion-v1-4 device = cuda pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16) pipe = pipe.to(device) prompt = a photo of an astronaut riding a horse on mars image = pipe(prompt).images[0] image.save(astronaut_rides_horse.png)

{'dataset': 'COCO2017 validation set', 'accuracy': 'Not optimized for FID scores'}

Stable Diffusion is a latent text-to-image diffusion model capable of generating photo-realistic images given any text input. The Stable-Diffusion-v1-4 checkpoint was fine-tuned on 225k steps at resolution 512x512 on laion-aesthetics v2 5+ and 10% dropping of the text-conditioning to improve classifier-free guidance sampling. This model is intended for research purposes and can be used for generating artworks, design, educational or creative tools, and research on generative models.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

prompthero/openjourney

StableDiffusionPipeline.from_pretrained('prompthero/openjourney')

{'prompt': 'string'}

['diffusers', 'torch']

from diffusers import StableDiffusionPipeline import torch model_id = prompthero/openjourney pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16) pipe = pipe.to(cuda) prompt = retro serie of different cars with different colors and shapes, mdjrny-v4 style image = pipe(prompt).images[0] image.save(./retro_cars.png)

{'dataset': 'Midjourney images', 'accuracy': 'Not specified'}

Openjourney is an open source Stable Diffusion fine-tuned model on Midjourney images, by PromptHero. It can be used for generating AI art based on text prompts.

Multimodal Text-to-Image

Hugging Face

Image Generation

runwayml/stable-diffusion-inpainting

StableDiffusionInpaintPipeline.from_pretrained('runwayml/stable-diffusion-inpainting')

{'prompt': 'Text prompt', 'image': 'PIL image', 'mask_image': 'PIL image (mask)'}

{'diffusers': 'from diffusers import StableDiffusionInpaintPipeline'}

{'import_code': 'from diffusers import StableDiffusionInpaintPipeline', 'instantiate_code': 'pipe = StableDiffusionInpaintPipeline.from_pretrained(runwayml/stable-diffusion-inpainting, revision=fp16, torch_dtype=torch.float16)', 'generate_image_code': 'image = pipe(prompt=prompt, image=image, mask_image=mask_image).images[0]', 'save_image_code': 'image.save(./yellow_cat_on_park_bench.png)'}

{'dataset': {'name': 'LAION-2B (en)', 'accuracy': 'Not optimized for FID scores'}}

Stable Diffusion Inpainting is a latent text-to-image diffusion model capable of generating photo-realistic images given any text input, with the extra capability of inpainting the pictures by using a mask.

Multimodal Text-to-Image

Hugging Face

Text-to-Image Generation

stabilityai/stable-diffusion-2-1-base

StableDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base', scheduler=EulerDiscreteScheduler.from_pretrained(stabilityai/stable-diffusion-2-1-base, subfolder=scheduler))

{'prompt': 'a photo of an astronaut riding a horse on mars'}

['diffusers', 'transformers', 'accelerate', 'scipy', 'safetensors']

{'install_dependencies': 'pip install diffusers transformers accelerate scipy safetensors', 'code': 'from diffusers import StableDiffusionPipeline, EulerDiscreteScheduler\nimport torch\nmodel_id = stabilityai/stable-diffusion-2-1-base\nscheduler = EulerDiscreteScheduler.from_pretrained(model_id, subfolder=scheduler)\npipe = StableDiffusionPipeline.from_pretrained(model_id, scheduler=scheduler, torch_dtype=torch.float16)\npipe = pipe.to(cuda)\nprompt = a photo of an astronaut riding a horse on mars\nimage = pipe(prompt).images[0]\nimage.save(astronaut_rides_horse.png)'}

{'dataset': 'COCO2017 validation set', 'accuracy': 'Not optimized for FID scores'}

Stable Diffusion v2-1-base is a diffusion-based text-to-image generation model that can generate and modify images based on text prompts. It is a Latent Diffusion Model that uses a fixed, pretrained text encoder (OpenCLIP-ViT/H). It is intended for research purposes only and can be used in areas such as safe deployment of models, understanding limitations and biases of generative models, generation of artworks, and research on generative models.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

hakurei/waifu-diffusion

StableDiffusionPipeline.from_pretrained('hakurei/waifu-diffusion')

{'prompt': 'text', 'guidance_scale': 'number'}

{'torch': 'torch', 'autocast': 'from torch', 'StableDiffusionPipeline': 'from diffusers'}

import torch from torch import autocast from diffusers import StableDiffusionPipeline pipe = StableDiffusionPipeline.from_pretrained( 'hakurei/waifu-diffusion', torch_dtype=torch.float32 ).to('cuda') prompt = 1girl, aqua eyes, baseball cap, blonde hair, closed mouth, earrings, green background, hat, hoop earrings, jewelry, looking at viewer, shirt, short hair, simple background, solo, upper body, yellow shirt with autocast(cuda): image = pipe(prompt, guidance_scale=6)[sample][0] image.save(test.png)

{'dataset': 'high-quality anime images', 'accuracy': 'not available'}

waifu-diffusion is a latent text-to-image diffusion model that has been conditioned on high-quality anime images through fine-tuning.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

stabilityai/sd-vae-ft-mse

StableDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4', vae='AutoencoderKL.from_pretrained(stabilityai/sd-vae-ft-mse)')

{'model': 'CompVis/stable-diffusion-v1-4', 'vae': 'AutoencoderKL.from_pretrained(stabilityai/sd-vae-ft-mse)'}

['diffusers']

from diffusers.models import AutoencoderKL from diffusers import StableDiffusionPipeline model = CompVis/stable-diffusion-v1-4 vae = AutoencoderKL.from_pretrained(stabilityai/sd-vae-ft-mse) pipe = StableDiffusionPipeline.from_pretrained(model, vae=vae)

{'dataset': [{'name': 'COCO 2017 (256x256, val, 5000 images)', 'accuracy': {'rFID': '4.70', 'PSNR': '24.5 +/- 3.7', 'SSIM': '0.71 +/- 0.13', 'PSIM': '0.92 +/- 0.27'}}, {'name': 'LAION-Aesthetics 5+ (256x256, subset, 10000 images)', 'accuracy': {'rFID': '1.88', 'PSNR': '27.3 +/- 4.7', 'SSIM': '0.83 +/- 0.11', 'PSIM': '0.65 +/- 0.34'}}]}

This model is a fine-tuned VAE decoder for the Stable Diffusion Pipeline. It is designed to be used with the diffusers library and can be integrated into existing workflows by including a vae argument to the StableDiffusionPipeline. The model has been finetuned on a 1:1 ratio of LAION-Aesthetics and LAION-Humans datasets and has been evaluated on COCO 2017 and LAION-Aesthetics 5+ datasets.

Multimodal Text-to-Image

Hugging Face

Text-to-Image Generation

stabilityai/stable-diffusion-2-1

StableDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1')

{'prompt': 'a photo of an astronaut riding a horse on mars'}

['diffusers', 'transformers', 'accelerate', 'scipy', 'safetensors']

from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler model_id = stabilityai/stable-diffusion-2-1 pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16) pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe = pipe.to(cuda) prompt = a photo of an astronaut riding a horse on mars image = pipe(prompt).images[0] image.save(astronaut_rides_horse.png)

{'dataset': 'COCO2017', 'accuracy': 'Not optimized for FID scores'}

Stable Diffusion v2-1 is a diffusion-based text-to-image generation model developed by Robin Rombach and Patrick Esser. It is capable of generating and modifying images based on text prompts in English. The model is trained on a subset of the LAION-5B dataset and is primarily intended for research purposes.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

Realistic_Vision_V1.4

pipeline('text-to-image', model=SG161222/Realistic_Vision_V1.4)

{'prompt': 'string', 'negative_prompt': 'string'}

['transformers', 'torch']

from transformers import pipeline model = pipeline('text-to-image', model='SG161222/Realistic_Vision_V1.4') prompt = 'a close up portrait photo of 26 y.o woman in wastelander clothes, long haircut, pale skin, slim body, background is city ruins, (high detailed skin:1.2), 8k uhd, dslr, soft lighting, high quality, film grain, Fujifilm XT3' negative_prompt = '(deformed iris, deformed pupils, semi-realistic, cgi, 3d, render, sketch, cartoon, drawing, anime:1.4), text, close up, cropped, out of frame, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck' result = model(prompt, negative_prompt=negative_prompt)

{'dataset': 'N/A', 'accuracy': 'N/A'}

Realistic_Vision_V1.4 is a text-to-image model that generates high-quality and detailed images based on textual prompts. It can be used for various applications such as generating realistic portraits, landscapes, and other types of images.

Multimodal Text-to-Image

Hugging Face

Image generation and modification based on text prompts

stabilityai/stable-diffusion-2-inpainting

StableDiffusionInpaintPipeline.from_pretrained('stabilityai/stable-diffusion-2-inpainting')

['prompt', 'image', 'mask_image']

['diffusers', 'transformers', 'accelerate', 'scipy', 'safetensors']

from diffusers import StableDiffusionInpaintPipeline pipe = StableDiffusionInpaintPipeline.from_pretrained('stabilityai/stable-diffusion-2-inpainting', torch_dtype=torch.float16) pipe.to(cuda) prompt = Face of a yellow cat, high resolution, sitting on a park bench image = pipe(prompt=prompt, image=image, mask_image=mask_image).images[0] image.save(./yellow_cat_on_park_bench.png)

{'dataset': 'COCO2017 validation set', 'accuracy': 'Not optimized for FID scores'}

A Latent Diffusion Model that uses a fixed, pretrained text encoder (OpenCLIP-ViT/H) to generate and modify images based on text prompts.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

dreamlike-art/dreamlike-photoreal-2.0

StableDiffusionPipeline.from_pretrained('dreamlike-art/dreamlike-photoreal-2.0')

{'prompt': 'photo, a church in the middle of a field of crops, bright cinematic lighting, gopro, fisheye lens'}

{'torch': 'torch.float16', 'diffusers': 'StableDiffusionPipeline'}

from diffusers import StableDiffusionPipeline import torch model_id = dreamlike-art/dreamlike-photoreal-2.0 pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16) pipe = pipe.to(cuda) prompt = photo, a church in the middle of a field of crops, bright cinematic lighting, gopro, fisheye lens image = pipe(prompt).images[0] image.save(./result.jpg)

{'dataset': 'Stable Diffusion 1.5', 'accuracy': 'Not specified'}

Dreamlike Photoreal 2.0 is a photorealistic model based on Stable Diffusion 1.5, made by dreamlike.art. It can be used to generate photorealistic images from text prompts.

Multimodal Text-to-Image

Hugging Face

Text-to-Image Generation

stabilityai/stable-diffusion-2

StableDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2', scheduler=EulerDiscreteScheduler.from_pretrained('stabilityai/stable-diffusion-2', subfolder=scheduler))

{'prompt': 'a photo of an astronaut riding a horse on mars'}

['diffusers', 'transformers', 'accelerate', 'scipy', 'safetensors']

from diffusers import StableDiffusionPipeline, EulerDiscreteScheduler model_id = stabilityai/stable-diffusion-2 scheduler = EulerDiscreteScheduler.from_pretrained(model_id, subfolder=scheduler) pipe = StableDiffusionPipeline.from_pretrained(model_id, scheduler=scheduler, torch_dtype=torch.float16) pipe = pipe.to(cuda) prompt = a photo of an astronaut riding a horse on mars image = pipe(prompt).images[0] image.save(astronaut_rides_horse.png)

{'dataset': 'COCO2017 validation set', 'accuracy': 'Not optimized for FID scores'}

Stable Diffusion v2 is a diffusion-based text-to-image generation model that can generate and modify images based on text prompts. It uses a fixed, pretrained text encoder (OpenCLIP-ViT/H) and is primarily intended for research purposes, such as safe deployment of models with potential to generate harmful content, understanding limitations and biases of generative models, and generation of artworks for design and artistic processes.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

andite/anything-v4.0

StableDiffusionPipeline.from_pretrained('andite/anything-v4.0')

{'model_id': 'andite/anything-v4.0', 'torch_dtype': 'torch.float16', 'device': 'cuda', 'prompt': 'hatsune_miku'}

{'diffusers': 'StableDiffusionPipeline', 'torch': 'torch'}

{'from diffusers import StableDiffusionPipeline': '', 'import torch': '', 'model_id = andite/anything-v4.0': '', 'pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)': '', 'pipe = pipe.to(cuda)': '', 'prompt = hatsune_miku': '', 'image = pipe(prompt).images[0]': '', 'image.save(./hatsune_miku.png)': ''}

{'dataset': 'Not specified', 'accuracy': 'Not specified'}

Anything V4 is a latent diffusion model for generating high-quality, highly detailed anime-style images with just a few prompts. It supports danbooru tags to generate images and can be used just like any other Stable Diffusion model.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

prompthero/openjourney-v4

pipeline('text-to-image', model='prompthero/openjourney-v4')

{'text': 'string'}

['transformers']

generate_image('your text here')

{'dataset': 'Midjourney v4 images', 'accuracy': 'Not provided'}

Openjourney v4 is trained on +124k Midjourney v4 images by PromptHero. It is used for generating images based on text inputs.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

stabilityai/sd-vae-ft-ema

StableDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4', vae=AutoencoderKL.from_pretrained('stabilityai/sd-vae-ft-ema'))

{'model': 'CompVis/stable-diffusion-v1-4', 'vae': 'AutoencoderKL.from_pretrained(stabilityai/sd-vae-ft-ema)'}

{'diffusers': 'diffusers library'}

from diffusers.models import AutoencoderKL from diffusers import StableDiffusionPipeline model = CompVis/stable-diffusion-v1-4 vae = AutoencoderKL.from_pretrained(stabilityai/sd-vae-ft-ema) pipe = StableDiffusionPipeline.from_pretrained(model, vae=vae)

{'dataset': {'COCO 2017 (256x256, val, 5000 images)': {'accuracy': {'rFID': 4.42, 'PSNR': '23.8 +/- 3.9', 'SSIM': '0.69 +/- 0.13', 'PSIM': '0.96 +/- 0.27'}}, 'LAION-Aesthetics 5+ (256x256, subset, 10000 images)': {'accuracy': {'rFID': 1.77, 'PSNR': '26.7 +/- 4.8', 'SSIM': '0.82 +/- 0.12', 'PSIM': '0.67 +/- 0.34'}}}}

This is a fine-tuned VAE decoder for the Stable Diffusion Pipeline. It has been fine-tuned on a 1:1 ratio of LAION-Aesthetics and LAION-Humans datasets. The decoder can be used as a drop-in replacement for the existing autoencoder.

Multimodal Text-to-Image

Hugging Face

Generate and modify images based on text prompts

stabilityai/stable-diffusion-2-depth

StableDiffusionDepth2ImgPipeline.from_pretrained('stabilityai/stable-diffusion-2-depth')

{'prompt': 'Text prompt to generate image', 'image': 'Initial image (optional)', 'negative_prompt': 'Negative text prompt to avoid certain features', 'strength': 'Strength of the prompt effect on the generated image'}

['pip install -U git+https://github.com/huggingface/transformers.git', 'pip install diffusers transformers accelerate scipy safetensors']

import torch import requests from PIL import Image from diffusers import StableDiffusionDepth2ImgPipeline pipe = StableDiffusionDepth2ImgPipeline.from_pretrained( stabilityai/stable-diffusion-2-depth, torch_dtype=torch.float16, ).to(cuda) url = http://images.cocodataset.org/val2017/000000039769.jpg init_image = Image.open(requests.get(url, stream=True).raw) prompt = two tigers n_propmt = bad, deformed, ugly, bad anotomy image = pipe(prompt=prompt, image=init_image, negative_prompt=n_propmt, strength=0.7).images[0]

{'dataset': 'COCO2017 validation set', 'accuracy': 'Not optimized for FID scores'}

Stable Diffusion v2 is a latent diffusion model that generates and modifies images based on text prompts. It uses a fixed, pretrained text encoder (OpenCLIP-ViT/H) and is developed by Robin Rombach and Patrick Esser. The model works with English language prompts and is intended for research purposes only.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

EimisAnimeDiffusion_1.0v

DiffusionPipeline.from_pretrained('eimiss/EimisAnimeDiffusion_1.0v')

['prompt']

huggingface_hub

from huggingface_hub import hf_hub_download; hf_hub_download('eimiss/EimisAnimeDiffusion_1.0v', 'prompt')

{'dataset': 'Not specified', 'accuracy': 'Not specified'}

EimisAnimeDiffusion_1.0v is a text-to-image model trained with high-quality and detailed anime images. It works well on anime and landscape generations and supports a Gradio Web UI.

Multimodal Text-to-Image

Hugging Face

Text-to-Image generation

stabilityai/stable-diffusion-2-base

StableDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base', scheduler=EulerDiscreteScheduler.from_pretrained('stabilityai/stable-diffusion-2-base', subfolder=scheduler))

{'prompt': 'a photo of an astronaut riding a horse on mars'}

['diffusers', 'transformers', 'accelerate', 'scipy', 'safetensors']

from diffusers import StableDiffusionPipeline, EulerDiscreteScheduler import torch model_id = stabilityai/stable-diffusion-2-base scheduler = EulerDiscreteScheduler.from_pretrained('stabilityai/stable-diffusion-2-base', subfolder=scheduler) pipe = StableDiffusionPipeline.from_pretrained(model_id, scheduler=scheduler, torch_dtype=torch.float16) pipe = pipe.to(cuda) prompt = a photo of an astronaut riding a horse on mars image = pipe(prompt).images[0] image.save(astronaut_rides_horse.png)

{'dataset': 'COCO2017 validation set', 'accuracy': 'Not optimized for FID scores'}

Stable Diffusion v2-base is a diffusion-based text-to-image generation model trained on a subset of LAION-5B dataset. It can be used to generate and modify images based on text prompts. The model uses a fixed, pretrained text encoder (OpenCLIP-ViT/H) and is intended for research purposes only.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

nitrosocke/nitro-diffusion

StableDiffusionPipeline.from_pretrained('nitrosocke/nitro-diffusion')

['prompt']

['torch', 'diffusers']

from diffusers import StableDiffusionPipeline import torch model_id = nitrosocke/nitro-diffusion pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16) pipe = pipe.to(cuda) prompt = archer arcane style magical princess with golden hair image = pipe(prompt).images[0] image.save(./magical_princess.png)

{'dataset': 'Stable Diffusion', 'accuracy': 'N/A'}

Nitro Diffusion is a fine-tuned Stable Diffusion model trained on three artstyles simultaneously while keeping each style separate from the others. It allows for high control of mixing, weighting, and single style use.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

Linaqruf/anything-v3.0

Text2ImagePipeline(model='Linaqruf/anything-v3.0')

transformers

{'dataset': '', 'accuracy': ''}

A text-to-image model that generates images from text descriptions.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

wavymulder/Analog-Diffusion

pipeline('text-to-image', model='wavymulder/Analog-Diffusion')

['prompt']

['transformers']

text_to_image('analog style landscape')

{'dataset': 'analog photographs', 'accuracy': 'Not specified'}

Analog Diffusion is a dreambooth model trained on a diverse set of analog photographs. It can generate images based on text prompts with an analog style. Use the activation token 'analog style' in your prompt to get the desired output. The model is available on the Hugging Face Inference API and can be used with the transformers library.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

dreamlike-art/dreamlike-diffusion-1.0

StableDiffusionPipeline.from_pretrained('dreamlike-art/dreamlike-diffusion-1.0')

['prompt']

['diffusers', 'torch']

from diffusers import StableDiffusionPipeline import torch model_id = dreamlike-art/dreamlike-diffusion-1.0 pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16) pipe = pipe.to(cuda) prompt = dreamlikeart, a grungy woman with rainbow hair, travelling between dimensions, dynamic pose, happy, soft eyes and narrow chin, extreme bokeh, dainty figure, long hair straight down, torn kawaii shirt and baggy jeans, In style of by Jordan Grimmer and greg rutkowski, crisp lines and color, complex background, particles, lines, wind, concept art, sharp focus, vivid colors image = pipe(prompt).images[0] image.save(./result.jpg)

{'dataset': 'high quality art', 'accuracy': 'not provided'}

Dreamlike Diffusion 1.0 is SD 1.5 fine tuned on high quality art, made by dreamlike.art.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

dreamlike-art/dreamlike-anime-1.0

StableDiffusionPipeline.from_pretrained('dreamlike-art/dreamlike-anime-1.0')

['prompt', 'negative_prompt']

['diffusers', 'torch']

from diffusers import StableDiffusionPipeline import torch model_id = dreamlike-art/dreamlike-anime-1.0 pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16) pipe = pipe.to(cuda) prompt = anime, masterpiece, high quality, 1girl, solo, long hair, looking at viewer, blush, smile, bangs, blue eyes, skirt, medium breasts, iridescent, gradient, colorful, besides a cottage, in the country negative_prompt = 'simple background, duplicate, retro style, low quality, lowest quality, 1980s, 1990s, 2000s, 2005 2006 2007 2008 2009 2010 2011 2012 2013, bad anatomy, bad proportions, extra digits, lowres, username, artist name, error, duplicate, watermark, signature, text, extra digit, fewer digits, worst quality, jpeg artifacts, blurry' image = pipe(prompt, negative_prompt=negative_prompt).images[0] image.save(./result.jpg)

{'dataset': 'N/A', 'accuracy': 'N/A'}

Dreamlike Anime 1.0 is a high quality anime model, made by dreamlike.art. It can be used to generate anime-style images based on text prompts. The model is trained on 768x768px images and works best with prompts that include 'photo anime, masterpiece, high quality, absurdres'. It can be used with the Stable Diffusion Pipeline from the diffusers library.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

Lykon/DreamShaper

pipeline('text-to-image', model=Lykon/DreamShaper)

transformers, torch

https://huggingface.co/spaces/Lykon/DreamShaper-webui

{'dataset': '', 'accuracy': ''}

Dream Shaper is a text-to-image model that generates artistic images based on the given input text. Read more about this model here: https://civitai.com/models/4384/dreamshaper

Multimodal Text-to-Image

Hugging Face

Text-to-Image

darkstorm2150/Protogen_v2.2_Official_Release

StableDiffusionPipeline.from_pretrained('darkstorm2150/Protogen_v2.2_Official_Release')

{'model_id': 'darkstorm2150/Protogen_v2.2_Official_Release', 'torch_dtype': 'torch.float16'}

{'diffusers': 'StableDiffusionPipeline, DPMSolverMultistepScheduler', 'torch': 'torch'}

from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler import torch prompt = ( modelshoot style, (extremely detailed CG unity 8k wallpaper), full shot body photo of the most beautiful artwork in the world, english medieval witch, black silk vale, pale skin, black silk robe, black cat, necromancy magic, medieval era, photorealistic painting by Ed Blinkey, Atey Ghailan, Studio Ghibli, by Jeremy Mann, Greg Manchess, Antonio Moro, trending on ArtStation, trending on CGSociety, Intricate, High Detail, Sharp focus, dramatic, photorealistic painting art by midjourney and greg rutkowski ) model_id = darkstorm2150/Protogen_v2.2_Official_Release pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16) pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe = pipe.to(cuda) image = pipe(prompt, num_inference_steps=25).images[0] image.save(./result.jpg)

{'dataset': 'Various datasets', 'accuracy': 'Not specified'}

Protogen v2.2 is a text-to-image model that generates high-quality images based on text prompts. It was warm-started with Stable Diffusion v1-5 and fine-tuned on a large amount of data from large datasets new and trending on civitai.com. The model can be used with the Stable Diffusion Pipeline and supports trigger words like 'modelshoot style' to enforce camera capture.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

gsdf/Counterfeit-V2.5

pipeline('text-to-image', model='gsdf/Counterfeit-V2.5')

text

transformers

((masterpiece,best quality)),1girl, solo, animal ears, rabbit, barefoot, knees up, dress, sitting, rabbit ears, short sleeves, looking at viewer, grass, short hair, smile, white hair, puffy sleeves, outdoors, puffy short sleeves, bangs, on ground, full body, animal, white dress, sunlight, brown eyes, dappled sunlight, day, depth of field

{'dataset': 'EasyNegative', 'accuracy': 'Not provided'}

Counterfeit-V2.5 is a text-to-image model that generates anime-style images based on text prompts. It has been updated for ease of use and can be used with negative prompts to create high-quality images.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

vintedois-diffusion-v0-1

pipeline('text-to-image', model='22h/vintedois-diffusion-v0-1')

['prompt', 'CFG Scale', 'Scheduler', 'Steps', 'Seed']

['transformers']

text2img('photo of an old man in a jungle, looking at the camera', CFG Scale=7.5, Scheduler='diffusers.EulerAncestralDiscreteScheduler', Steps=30, Seed=44)

{'dataset': 'large amount of high quality images', 'accuracy': 'not specified'}

Vintedois (22h) Diffusion model trained by Predogl and piEsposito with open weights, configs and prompts. This model generates beautiful images without a lot of prompt engineering. It can also generate high fidelity faces with a little amount of steps.

Multimodal Text-to-Image

Hugging Face

Image generation and modification based on text prompts

stabilityai/stable-diffusion-x4-upscaler

StableDiffusionUpscalePipeline.from_pretrained('stabilityai/stable-diffusion-x4-upscaler')

{'model_id': 'stabilityai/stable-diffusion-x4-upscaler', 'torch_dtype': 'torch.float16'}

['diffusers', 'transformers', 'accelerate', 'scipy', 'safetensors', 'xformers (optional, for memory efficient attention)']

pip install diffusers transformers accelerate scipy safetensors import requests from PIL import Image from io import BytesIO from diffusers import StableDiffusionUpscalePipeline import torch model_id = stabilityai/stable-diffusion-x4-upscaler pipeline = StableDiffusionUpscalePipeline.from_pretrained(model_id, torch_dtype=torch.float16) pipeline = pipeline.to(cuda) url = https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale/low_res_cat.png response = requests.get(url) low_res_img = Image.open(BytesIO(response.content)).convert(RGB) low_res_img = low_res_img.resize((128, 128)) prompt = a white cat upscaled_image = pipeline(prompt=prompt, image=low_res_img).images[0] upscaled_image.save(upsampled_cat.png)

{'dataset': 'COCO2017 validation set', 'accuracy': 'Not optimized for FID scores'}

Stable Diffusion x4 upscaler is a latent diffusion model trained on a 10M subset of LAION containing images >2048x2048. It can be used to generate and modify images based on text prompts. The model receives a noise_level as an input parameter, which can be used to add noise to the low-resolution input according to a predefined diffusion schedule. The model is trained with English captions and might not work well with other languages.

Multimodal Text-to-Image

Hugging Face

Text-to-Image

darkstorm2150/Protogen_x5.8_Official_Release

StableDiffusionPipeline.from_pretrained('darkstorm2150/Protogen_v5.8_Official_Release')

{'model_id': 'darkstorm2150/Protogen_v5.8_Official_Release', 'torch_dtype': 'torch.float16'}

['torch', 'diffusers']

from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler import torch prompt = ( modelshoot style, (extremely detailed CG unity 8k wallpaper), full shot body photo of the most beautiful artwork in the world, english medieval witch, black silk vale, pale skin, black silk robe, black cat, necromancy magic, medieval era, photorealistic painting by Ed Blinkey, Atey Ghailan, Studio Ghibli, by Jeremy Mann, Greg Manchess, Antonio Moro, trending on ArtStation, trending on CGSociety, Intricate, High Detail, Sharp focus, dramatic, photorealistic painting art by midjourney and greg rutkowski ) model_id = darkstorm2150/Protogen_v5.8_Official_Release pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16) pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe = pipe.to(cuda) image = pipe(prompt, num_inference_steps=25).images[0] image.save(./result.jpg)

{'dataset': 'unknown', 'accuracy': 'unknown'}

Protogen x5.8 is a text-to-image model that generates images based on text prompts. It was warm-started with Stable Diffusion v1-5 and is rebuilt using dreamlikePhotoRealV2.ckpt as a core. The model uses granular adaptive learning techniques for fine-grained adjustments and can be used just like any other Stable Diffusion model.

Multimodal Image-to-Text

Hugging Face Transformers

Image Captioning

nlpconnect/vit-gpt2-image-captioning

VisionEncoderDecoderModel.from_pretrained('nlpconnect/vit-gpt2-image-captioning')

{'model': 'nlpconnect/vit-gpt2-image-captioning'}

['transformers', 'torch', 'PIL']

from transformers import VisionEncoderDecoderModel, ViTImageProcessor, AutoTokenizer import torch from PIL import Image model = VisionEncoderDecoderModel.from_pretrained(nlpconnect/vit-gpt2-image-captioning) feature_extractor = ViTImageProcessor.from_pretrained(nlpconnect/vit-gpt2-image-captioning) tokenizer = AutoTokenizer.from_pretrained(nlpconnect/vit-gpt2-image-captioning) device = torch.device(cuda if torch.cuda.is_available() else cpu) model.to(device) max_length = 16 num_beams = 4 gen_kwargs = {max_length: max_length, num_beams: num_beams} def predict_step(image_paths): images = [] for image_path in image_paths: i_image = Image.open(image_path) if i_image.mode != RGB: i_image = i_image.convert(mode=RGB) images.append(i_image) pixel_values = feature_extractor(images=images, return_tensors=pt).pixel_values pixel_values = pixel_values.to(device) output_ids = model.generate(pixel_values, **gen_kwargs) preds = tokenizer.batch_decode(output_ids, skip_special_tokens=True) preds = [pred.strip() for pred in preds] return preds predict_step(['doctor.e16ba4e4.jpg']) # ['a woman in a hospital bed with a woman in a hospital bed']

{'dataset': 'Not provided', 'accuracy': 'Not provided'}

An image captioning model that uses transformers to generate captions for input images. The model is based on the Illustrated Image Captioning using transformers approach.

Multimodal Text-to-Image

Hugging Face

Image Upscaling

stabilityai/sd-x2-latent-upscaler

StableDiffusionLatentUpscalePipeline.from_pretrained(stabilityai/sd-x2-latent-upscaler)

{'prompt': 'text prompt', 'image': 'low resolution latents', 'num_inference_steps': 20, 'guidance_scale': 0, 'generator': 'torch generator'}

['git+https://github.com/huggingface/diffusers.git', 'transformers', 'accelerate', 'scipy', 'safetensors']

from diffusers import StableDiffusionLatentUpscalePipeline, StableDiffusionPipeline import torch pipeline = StableDiffusionPipeline.from_pretrained(CompVis/stable-diffusion-v1-4, torch_dtype=torch.float16) pipeline.to(cuda) upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(stabilityai/sd-x2-latent-upscaler, torch_dtype=torch.float16) upscaler.to(cuda) prompt = a photo of an astronaut high resolution, unreal engine, ultra realistic generator = torch.manual_seed(33) low_res_latents = pipeline(prompt, generator=generator, output_type=latent).images upscaled_image = upscaler(prompt=prompt, image=low_res_latents, num_inference_steps=20, guidance_scale=0, generator=generator).images[0] upscaled_image.save(astronaut_1024.png)

{'dataset': 'LAION-2B', 'accuracy': 'Not specified'}

Stable Diffusion x2 latent upscaler is a diffusion-based upscaler model developed by Katherine Crowson in collaboration with Stability AI. It is designed to upscale Stable Diffusion's latent denoised image embeddings, allowing for fast text-to-image and upscaling pipelines. The model was trained on a high-resolution subset of the LAION-2B dataset and works with all Stable Diffusion checkpoints.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

kha-white/manga-ocr-base

pipeline('ocr', model='kha-white/manga-ocr-base')

image

transformers

{'dataset': 'manga109s', 'accuracy': ''}

Optical character recognition for Japanese text, with the main focus being Japanese manga. It uses Vision Encoder Decoder framework. Manga OCR can be used as a general purpose printed Japanese OCR, but its main goal was to provide a high quality text recognition, robust against various scenarios specific to manga: both vertical and horizontal text, text with furigana, text overlaid on images, wide variety of fonts and font styles, and low quality images.

Multimodal Image-to-Text

Hugging Face Transformers

Image Captioning

blip-image-captioning-base

BlipForConditionalGeneration.from_pretrained('Salesforce/blip-image-captioning-base')

['raw_image', 'text', 'return_tensors']

['requests', 'PIL', 'transformers']

import requests from PIL import Image from transformers import BlipProcessor, BlipForConditionalGeneration processor = BlipProcessor.from_pretrained(Salesforce/blip-image-captioning-base) model = BlipForConditionalGeneration.from_pretrained(Salesforce/blip-image-captioning-base) img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB') text = a photography of inputs = processor(raw_image, text, return_tensors=pt) out = model.generate(**inputs) print(processor.decode(out[0], skip_special_tokens=True))

{'dataset': 'COCO', 'accuracy': {'CIDEr': '+2.8%'}}

BLIP (Bootstrapping Language-Image Pre-training) is a new vision-language pre-training (VLP) framework that transfers flexibly to both vision-language understanding and generation tasks. It effectively utilizes noisy web data by bootstrapping the captions, where a captioner generates synthetic captions and a filter removes the noisy ones. This model is pre-trained on the COCO dataset with a base architecture (ViT base backbone).

Multimodal Image-to-Text

Transformers

Image Captioning

blip-image-captioning-large

BlipForConditionalGeneration.from_pretrained(Salesforce/blip-image-captioning-large)

{'raw_image': 'Image', 'text': 'Optional Text'}

{'transformers': 'BlipProcessor, BlipForConditionalGeneration', 'PIL': 'Image', 'requests': 'requests'}

{'import_requests': 'import requests', 'import_PIL': 'from PIL import Image', 'import_transformers': 'from transformers import BlipProcessor, BlipForConditionalGeneration', 'load_processor': 'processor = BlipProcessor.from_pretrained(Salesforce/blip-image-captioning-large)', 'load_model': 'model = BlipForConditionalGeneration.from_pretrained(Salesforce/blip-image-captioning-large)', 'load_image': "img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg'\nraw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')", 'conditional_captioning': 'text = a photography of\ninputs = processor(raw_image, text, return_tensors=pt)\nout = model.generate(**inputs)\nprint(processor.decode(out[0], skip_special_tokens=True))', 'unconditional_captioning': 'inputs = processor(raw_image, return_tensors=pt)\nout = model.generate(**inputs)\nprint(processor.decode(out[0], skip_special_tokens=True))'}

{'dataset': 'COCO', 'accuracy': {'image-text retrieval': '+2.7% recall@1', 'image captioning': '+2.8% CIDEr', 'VQA': '+1.6% VQA score'}}

BLIP is a Vision-Language Pre-training (VLP) framework that achieves state-of-the-art results on a wide range of vision-language tasks, such as image-text retrieval, image captioning, and VQA. It effectively utilizes noisy web data by bootstrapping the captions, where a captioner generates synthetic captions and a filter removes the noisy ones.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

microsoft/trocr-base-printed

VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-printed')

['images', 'return_tensors']

['transformers', 'PIL', 'requests']

from transformers import TrOCRProcessor, VisionEncoderDecoderModel from PIL import Image import requests url = 'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg' image = Image.open(requests.get(url, stream=True).raw).convert(RGB) processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-printed') model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-printed') pixel_values = processor(images=image, return_tensors=pt).pixel_values generated_ids = model.generate(pixel_values) generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

{'dataset': 'SROIE', 'accuracy': 'Not provided'}

TrOCR model fine-tuned on the SROIE dataset. It was introduced in the paper TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models by Li et al. and first released in this repository. The TrOCR model is an encoder-decoder model, consisting of an image Transformer as encoder, and a text Transformer as decoder. The image encoder was initialized from the weights of BEiT, while the text decoder was initialized from the weights of RoBERTa.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

blip2-opt-2.7b

Blip2ForConditionalGeneration.from_pretrained('Salesforce/blip2-opt-2.7b')

{'img_url': 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg', 'question': 'how many dogs are in the picture?'}

['transformers', 'PIL', 'requests']

{'import_requests': 'import requests', 'import_PIL': 'from PIL import Image', 'import_transformers': 'from transformers import BlipProcessor, Blip2ForConditionalGeneration', 'load_processor': "processor = BlipProcessor.from_pretrained('Salesforce/blip2-opt-2.7b')", 'load_model': "model = Blip2ForConditionalGeneration.from_pretrained('Salesforce/blip2-opt-2.7b')", 'load_image': "raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')", 'process_inputs': "inputs = processor(raw_image, question, return_tensors='pt')", 'generate_output': 'out = model.generate(**inputs)', 'decode_output': 'print(processor.decode(out[0], skip_special_tokens=True))'}

{'dataset': 'LAION', 'accuracy': 'Not specified'}

BLIP-2 model, leveraging OPT-2.7b (a large language model with 2.7 billion parameters). It was introduced in the paper BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models by Li et al. and first released in this repository. The goal for the model is to predict the next text token, given the query embeddings and the previous text. This allows the model to be used for tasks like image captioning, visual question answering (VQA), and chat-like conversations by feeding the image and the previous conversation as prompt to the model.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

microsoft/trocr-small-handwritten

VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-small-handwritten')

['images', 'return_tensors']

['transformers', 'PIL', 'requests']

from transformers import TrOCRProcessor, VisionEncoderDecoderModel from PIL import Image import requests url = 'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg' image = Image.open(requests.get(url, stream=True).raw).convert('RGB') processor = TrOCRProcessor.from_pretrained('microsoft/trocr-small-handwritten') model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-small-handwritten') pixel_values = processor(images=image, return_tensors='pt').pixel_values generated_ids = model.generate(pixel_values) generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

{'dataset': 'IAM', 'accuracy': 'Not provided'}

TrOCR model fine-tuned on the IAM dataset. It was introduced in the paper TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models by Li et al. and first released in this repository.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

naver-clova-ix/donut-base

AutoModel.from_pretrained('naver-clova-ix/donut-base')

image

transformers

result = donut(image_path)

{'dataset': 'arxiv:2111.15664', 'accuracy': 'Not provided'}

Donut consists of a vision encoder (Swin Transformer) and a text decoder (BART). Given an image, the encoder first encodes the image into a tensor of embeddings (of shape batch_size, seq_len, hidden_size), after which the decoder autoregressively generates text, conditioned on the encoding of the encoder.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

promptcap-coco-vqa

PromptCap('vqascore/promptcap-coco-vqa')

{'prompt': 'string', 'image': 'string'}

pip install promptcap

['import torch', 'from promptcap import PromptCap', 'model = PromptCap(vqascore/promptcap-coco-vqa)', 'if torch.cuda.is_available():', ' model.cuda()', 'prompt = please describe this image according to the given question: what piece of clothing is this boy putting on?', 'image = glove_boy.jpeg', 'print(model.caption(prompt, image))']

{'dataset': {'coco': {'accuracy': '150 CIDEr'}, 'OK-VQA': {'accuracy': '60.4%'}, 'A-OKVQA': {'accuracy': '59.6%'}}}

PromptCap is a captioning model that can be controlled by natural language instruction. The instruction may contain a question that the user is interested in. It achieves SOTA performance on COCO captioning (150 CIDEr) and knowledge-based VQA tasks when paired with GPT-3 (60.4% on OK-VQA and 59.6% on A-OKVQA).

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

microsoft/git-base-coco

pipeline('text-generation', model='microsoft/git-base-coco')

image

transformers

See the model hub for fine-tuned versions on a task that interests you.

{'dataset': 'COCO', 'accuracy': 'Refer to the paper for evaluation results.'}

GIT (short for GenerativeImage2Text) model, base-sized version, fine-tuned on COCO. It was introduced in the paper GIT: A Generative Image-to-text Transformer for Vision and Language by Wang et al. and first released in this repository. The model is a Transformer decoder conditioned on both CLIP image tokens and text tokens. It can be used for tasks like image and video captioning, visual question answering (VQA) on images and videos, and even image classification (by simply conditioning the model on the image and asking it to generate a class for it in text).

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

AICVTG_What_if_a_machine_could_create_captions_automatically

VisionEncoderDecoderModel.from_pretrained('facebook/mmt-en-de')

{'image_paths': 'List of image file paths', 'max_length': 20, 'num_beams': 8}

{'transformers': 'from transformers import VisionEncoderDecoderModel, ViTFeatureExtractor, AutoTokenizer', 'torch': 'import torch', 'Image': 'from PIL import Image'}

predict_step(['Image URL.jpg'])

{'dataset': 'Not specified', 'accuracy': 'Not specified'}

This is an image captioning model training by Zayn

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

blip2-flan-t5-xl

Blip2ForConditionalGeneration.from_pretrained('Salesforce/blip2-flan-t5-xl')

['raw_image', 'question']

['transformers', 'requests', 'PIL']

['import requests', 'from PIL import Image', 'from transformers import BlipProcessor, Blip2ForConditionalGeneration', 'processor = BlipProcessor.from_pretrained(Salesforce/blip2-flan-t5-xl)', 'model = Blip2ForConditionalGeneration.from_pretrained(Salesforce/blip2-flan-t5-xl)', "img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg'", "raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')", 'question = how many dogs are in the picture?', 'inputs = processor(raw_image, question, return_tensors=pt)', 'out = model.generate(**inputs)', 'print(processor.decode(out[0], skip_special_tokens=True))']

{'dataset': 'LAION', 'accuracy': 'Not provided'}

BLIP-2 model, leveraging Flan T5-xl (a large language model). It was introduced in the paper BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models by Li et al. and first released in this repository. The goal for the model is to predict the next text token, giving the query embeddings and the previous text. This allows the model to be used for tasks like image captioning, visual question answering (VQA), and chat-like conversations by feeding the image and the previous conversation as prompt to the model.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

blip2-flan-t5-xxl

Blip2ForConditionalGeneration.from_pretrained('Salesforce/blip2-flan-t5-xxl')

{'raw_image': 'Image', 'question': 'Text'}

['requests', 'PIL', 'transformers']

import requests from PIL import Image from transformers import BlipProcessor, Blip2ForConditionalGeneration processor = BlipProcessor.from_pretrained(Salesforce/blip2-flan-t5-xxl) model = Blip2ForConditionalGeneration.from_pretrained(Salesforce/blip2-flan-t5-xxl) img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB') question = how many dogs are in the picture? inputs = processor(raw_image, question, return_tensors=pt) out = model.generate(**inputs) print(processor.decode(out[0], skip_special_tokens=True))

{'dataset': 'LAION', 'accuracy': 'Not provided'}

BLIP-2 model, leveraging Flan T5-xxl (a large language model). It was introduced in the paper BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models by Li et al. and first released in this repository. The model is used for tasks like image captioning, visual question answering (VQA), and chat-like conversations by feeding the image and the previous conversation as prompt to the model.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

microsoft/trocr-large-handwritten

VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-large-handwritten')

{'pretrained_model_name_or_path': 'microsoft/trocr-large-handwritten'}

{'packages': ['transformers', 'PIL', 'requests']}

from transformers import TrOCRProcessor, VisionEncoderDecoderModel from PIL import Image import requests url = 'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg' image = Image.open(requests.get(url, stream=True).raw).convert(RGB) processor = TrOCRProcessor.from_pretrained('microsoft/trocr-large-handwritten') model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-large-handwritten') pixel_values = processor(images=image, return_tensors=pt).pixel_values generated_ids = model.generate(pixel_values) generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

{'dataset': 'IAM', 'accuracy': 'Not specified'}

TrOCR model fine-tuned on the IAM dataset. It was introduced in the paper TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models by Li et al. and first released in this repository. The TrOCR model is an encoder-decoder model, consisting of an image Transformer as encoder, and a text Transformer as decoder. The image encoder was initialized from the weights of BEiT, while the text decoder was initialized from the weights of RoBERTa.

Multimodal Image-to-Text

Hugging Face Transformers

Image-to-Text

ydshieh/vit-gpt2-coco-en

VisionEncoderDecoderModel.from_pretrained('ydshieh/vit-gpt2-coco-en')

{'loc': 'ydshieh/vit-gpt2-coco-en'}

['torch', 'requests', 'PIL', 'transformers']

import torch import requests from PIL import Image from transformers import ViTFeatureExtractor, AutoTokenizer, VisionEncoderDecoderModel loc = ydshieh/vit-gpt2-coco-en feature_extractor = ViTFeatureExtractor.from_pretrained(loc) tokenizer = AutoTokenizer.from_pretrained(loc) model = VisionEncoderDecoderModel.from_pretrained(loc) model.eval() def predict(image): pixel_values = feature_extractor(images=image, return_tensors=pt).pixel_values with torch.no_grad(): output_ids = model.generate(pixel_values, max_length=16, num_beams=4, return_dict_in_generate=True).sequences preds = tokenizer.batch_decode(output_ids, skip_special_tokens=True) preds = [pred.strip() for pred in preds] return preds url = http://images.cocodataset.org/val2017/000000039769.jpg with Image.open(requests.get(url, stream=True).raw) as image: preds = predict(image) print(preds)

{'dataset': 'COCO', 'accuracy': 'Not specified'}

A proof-of-concept model for the Hugging Face FlaxVisionEncoderDecoder Framework that produces reasonable image captioning results.

Multimodal Image-to-Text

Hugging Face Transformers

text2text-generation

blip2-opt-6.7b

pipeline('text2text-generation', model='salesforce/blip2-opt-6.7b')

image, optional text

transformers

Refer to the documentation

{'dataset': 'LAION', 'accuracy': 'Not specified'}

BLIP-2 model, leveraging OPT-6.7b (a large language model with 6.7 billion parameters). It was introduced in the paper BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models by Li et al. and first released in this repository. The goal for the model is to predict the next text token, giving the query embeddings and the previous text. This allows the model to be used for tasks like image captioning, visual question answering (VQA), and chat-like conversations by feeding the image and the previous conversation as prompt to the model.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

microsoft/trocr-base-handwritten

VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten')

{'pretrained_model_name_or_path': 'microsoft/trocr-base-handwritten'}

['transformers', 'PIL', 'requests']

from transformers import TrOCRProcessor, VisionEncoderDecoderModel from PIL import Image import requests url = 'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg' image = Image.open(requests.get(url, stream=True).raw).convert('RGB') processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten') model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten') pixel_values = processor(images=image, return_tensors='pt').pixel_values generated_ids = model.generate(pixel_values) generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

{'dataset': 'IAM', 'accuracy': 'Not specified'}

TrOCR model fine-tuned on the IAM dataset. It was introduced in the paper TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models by Li et al. and first released in this repository. The TrOCR model is an encoder-decoder model, consisting of an image Transformer as encoder, and a text Transformer as decoder. The image encoder was initialized from the weights of BEiT, while the text decoder was initialized from the weights of RoBERTa.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

donut-base-finetuned-cord-v2

AutoModel.from_pretrained('naver-clova-ix/donut-base-finetuned-cord-v2')

{'image': 'path_to_image'}

transformers

from transformers import pipeline; image_to_text = pipeline('image-to-text', model='naver-clova-ix/donut-base-finetuned-cord-v2'); image_to_text('path_to_image')

{'dataset': 'CORD', 'accuracy': 'Not provided'}

Donut consists of a vision encoder (Swin Transformer) and a text decoder (BART). Given an image, the encoder first encodes the image into a tensor of embeddings (of shape batch_size, seq_len, hidden_size), after which the decoder autoregressively generates text, conditioned on the encoding of the encoder. This model is fine-tuned on CORD, a document parsing dataset.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

git-large-coco

GenerativeImage2TextModel.from_pretrained('microsoft/git-large-coco')

image, text

transformers

For code examples, we refer to the documentation.

{'dataset': 'COCO', 'accuracy': 'See table 11 in the paper for more details.'}

GIT (short for GenerativeImage2Text) model, large-sized version, fine-tuned on COCO. It was introduced in the paper GIT: A Generative Image-to-text Transformer for Vision and Language by Wang et al. and first released in this repository.

Multimodal Visual Question Answering

Hugging Face Transformers

Transformers

google/pix2struct-chartqa-base

Pix2StructForConditionalGeneration.from_pretrained('google/pix2struct-chartqa-base')

['t5x_checkpoint_path', 'pytorch_dump_path', 'use-large']

transformers

python convert_pix2struct_checkpoint_to_pytorch.py --t5x_checkpoint_path PATH_TO_T5X_CHECKPOINTS --pytorch_dump_path PATH_TO_SAVE

{'dataset': 'ChartQA', 'accuracy': 'Not provided'}

Pix2Struct is an image encoder - text decoder model that is trained on image-text pairs for various tasks, including image captionning and visual question answering. The model is pretrained by learning to parse masked screenshots of web pages into simplified HTML. It can achieve state-of-the-art results in six out of nine tasks across four domains: documents, illustrations, user interfaces, and natural images.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

google/pix2struct-base

Pix2StructForConditionalGeneration.from_pretrained('google/pix2struct-base')

{'t5x_checkpoint_path': 'PATH_TO_T5X_CHECKPOINTS', 'pytorch_dump_path': 'PATH_TO_SAVE'}

{'transformers': '4.15.0', 'torch': '1.10.1'}

from transformers import Pix2StructForConditionalGeneration, Pix2StructProcessor model = Pix2StructForConditionalGeneration.from_pretrained(PATH_TO_SAVE) processor = Pix2StructProcessor.from_pretrained(PATH_TO_SAVE) model.push_to_hub(USERNAME/MODEL_NAME) processor.push_to_hub(USERNAME/MODEL_NAME)

{'dataset': [{'name': 'Documents', 'accuracy': 'N/A'}, {'name': 'Illustrations', 'accuracy': 'N/A'}, {'name': 'User Interfaces', 'accuracy': 'N/A'}, {'name': 'Natural Images', 'accuracy': 'N/A'}]}

Pix2Struct is an image encoder - text decoder model that is trained on image-text pairs for various tasks, including image captioning and visual question answering. The model is pretrained by learning to parse masked screenshots of web pages into simplified HTML. It can achieve state-of-the-art results in six out of nine tasks across four domains: documents, illustrations, user interfaces, and natural images.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

google/pix2struct-textcaps-base

Pix2StructForConditionalGeneration.from_pretrained('google/pix2struct-textcaps-base')

{'images': 'image', 'text': 'text', 'return_tensors': 'pt', 'max_patches': 512}

['transformers', 'PIL', 'requests']

['import requests', 'from PIL import Image', 'from transformers import Pix2StructForConditionalGeneration, Pix2StructProcessor', 'url = https://www.ilankelman.org/stopsigns/australia.jpg', 'image = Image.open(requests.get(url, stream=True).raw)', 'model = Pix2StructForConditionalGeneration.from_pretrained(google/pix2struct-textcaps-base)', 'processor = Pix2StructProcessor.from_pretrained(google/pix2struct-textcaps-base)', 'inputs = processor(images=image, return_tensors=pt)', 'predictions = model.generate(**inputs)', 'print(processor.decode(predictions[0], skip_special_tokens=True))']

{'dataset': 'TextCaps', 'accuracy': 'state-of-the-art'}

Pix2Struct is an image encoder - text decoder model that is trained on image-text pairs for various tasks, including image captioning and visual question answering. It is pretrained by learning to parse masked screenshots of web pages into simplified HTML. The web, with its richness of visual elements cleanly reflected in the HTML structure, provides a large source of pretraining data well suited to the diversity of downstream tasks.

Multimodal Image-to-Text

Hugging Face Transformers

Image Captioning

microsoft/git-base

pipeline('image-to-text', model='microsoft/git-base')

image

transformers

git_base(image)

{'dataset': ['COCO', 'Conceptual Captions (CC3M)', 'SBU', 'Visual Genome (VG)', 'Conceptual Captions (CC12M)', 'ALT200M'], 'accuracy': 'Refer to the paper for evaluation results'}

GIT (short for GenerativeImage2Text) model, base-sized version. It was introduced in the paper GIT: A Generative Image-to-text Transformer for Vision and Language by Wang et al. and first released in this repository. The model is trained using 'teacher forcing' on a lot of (image, text) pairs. The goal for the model is simply to predict the next text token, giving the image tokens and previous text tokens. This allows the model to be used for tasks like image and video captioning, visual question answering (VQA) on images and videos, and even image classification (by simply conditioning the model on the image and asking it to generate a class for it in text).

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

microsoft/trocr-large-printed

VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-large-printed')

{'TrOCRProcessor': "from_pretrained('microsoft/trocr-large-printed')", 'images': 'image', 'return_tensors': 'pt'}

{'transformers': 'pip install transformers', 'PIL': 'pip install pillow', 'requests': 'pip install requests'}

from transformers import TrOCRProcessor, VisionEncoderDecoderModel from PIL import Image import requests url = 'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg' image = Image.open(requests.get(url, stream=True).raw).convert(RGB) processor = TrOCRProcessor.from_pretrained('microsoft/trocr-large-printed') model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-large-printed') pixel_values = processor(images=image, return_tensors=pt).pixel_values generated_ids = model.generate(pixel_values) generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

{'dataset': 'SROIE', 'accuracy': 'Not provided'}

TrOCR model fine-tuned on the SROIE dataset. It was introduced in the paper TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models by Li et al. and first released in this repository. The TrOCR model is an encoder-decoder model, consisting of an image Transformer as encoder, and a text Transformer as decoder. The image encoder was initialized from the weights of BEiT, while the text decoder was initialized from the weights of RoBERTa.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

google/deplot

Pix2StructForConditionalGeneration.from_pretrained('google/deplot')

{'images': 'image', 'text': 'question', 'return_tensors': 'pt', 'max_new_tokens': 512}

{'transformers': 'Pix2StructForConditionalGeneration, Pix2StructProcessor', 'requests': 'requests', 'PIL': 'Image'}

from transformers import Pix2StructForConditionalGeneration, Pix2StructProcessor import requests from PIL import Image model = Pix2StructForConditionalGeneration.from_pretrained('google/deplot') processor = Pix2StructProcessor.from_pretrained('google/deplot') url = https://raw.githubusercontent.com/vis-nlp/ChartQA/main/ChartQA%20Dataset/val/png/5090.png image = Image.open(requests.get(url, stream=True).raw) inputs = processor(images=image, text=Generate underlying data table of the figure below:, return_tensors=pt) predictions = model.generate(**inputs, max_new_tokens=512) print(processor.decode(predictions[0], skip_special_tokens=True))

{'dataset': 'ChartQA', 'accuracy': '24.0% improvement over finetuned SOTA'}

DePlot is a model that translates the image of a plot or chart to a linearized table. It decomposes the challenge of visual language reasoning into two steps: (1) plot-to-text translation, and (2) reasoning over the translated text. The output of DePlot can then be directly used to prompt a pretrained large language model (LLM), exploiting the few-shot reasoning capabilities of LLMs.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

git-large-textcaps

AutoModelForCausalLM.from_pretrained('microsoft/git-large-textcaps')

image, text

transformers

N/A

{'dataset': 'TextCaps', 'accuracy': 'Refer to the paper'}

GIT (short for GenerativeImage2Text) model, large-sized version, fine-tuned on TextCaps. It was introduced in the paper GIT: A Generative Image-to-text Transformer for Vision and Language by Wang et al. and first released in this repository. The model is trained using 'teacher forcing' on a lot of (image, text) pairs. The goal for the model is simply to predict the next text token, giving the image tokens and previous text tokens. This allows the model to be used for tasks like image and video captioning, visual question answering (VQA) on images and videos, and even image classification (by simply conditioning the model on the image and asking it to generate a class for it in text).

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

git-large-r-textcaps

pipeline('text-generation', model='microsoft/git-large-r-textcaps')

image

transformers

{'dataset': 'TextCaps', 'accuracy': ''}

GIT (short for GenerativeImage2Text) model, large-sized version, fine-tuned on TextCaps. It was introduced in the paper GIT: A Generative Image-to-text Transformer for Vision and Language by Wang et al. and first released in this repository. The model is trained using 'teacher forcing' on a lot of (image, text) pairs. The goal for the model is simply to predict the next text token, giving the image tokens and previous text tokens. This allows the model to be used for tasks like image and video captioning, visual question answering (VQA) on images and videos, and even image classification (by simply conditioning the model on the image and asking it to generate a class for it in text).

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

microsoft/trocr-small-stage1

VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-small-stage1')

{'url': 'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg'}

['transformers', 'PIL', 'requests', 'torch']

from transformers import TrOCRProcessor, VisionEncoderDecoderModel from PIL import Image import requests import torch url = 'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg' image = Image.open(requests.get(url, stream=True).raw).convert('RGB') processor = TrOCRProcessor.from_pretrained('microsoft/trocr-small-stage1') model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-small-stage1') pixel_values = processor(image, return_tensors='pt').pixel_values decoder_input_ids = torch.tensor([[model.config.decoder.decoder_start_token_id]]) outputs = model(pixel_values=pixel_values, decoder_input_ids=decoder_input_ids)

{'dataset': 'IAM', 'accuracy': 'Not provided'}

TrOCR pre-trained only model. It was introduced in the paper TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models by Li et al. and first released in this repository. The TrOCR model is an encoder-decoder model, consisting of an image Transformer as encoder, and a text Transformer as decoder. The image encoder was initialized from the weights of DeiT, while the text decoder was initialized from the weights of UniLM. Images are presented to the model as a sequence of fixed-size patches (resolution 16x16), which are linearly embedded. One also adds absolute position embeddings before feeding the sequence to the layers of the Transformer encoder. Next, the Transformer text decoder autoregressively generates tokens.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

microsoft/trocr-small-printed

VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-small-printed')

{'image': "Image.open(requests.get(url, stream=True).raw).convert('RGB')", 'processor': "TrOCRProcessor.from_pretrained('microsoft/trocr-small-printed')"}

['transformers', 'PIL', 'requests']

from transformers import TrOCRProcessor, VisionEncoderDecoderModel from PIL import Image import requests url = 'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg' image = Image.open(requests.get(url, stream=True).raw).convert('RGB') processor = TrOCRProcessor.from_pretrained('microsoft/trocr-small-printed') model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-small-printed') pixel_values = processor(images=image, return_tensors='pt').pixel_values generated_ids = model.generate(pixel_values) generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

{'dataset': 'SROIE', 'accuracy': 'Not specified'}

TrOCR model fine-tuned on the SROIE dataset. It was introduced in the paper TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models by Li et al. and first released in this repository. The TrOCR model is an encoder-decoder model, consisting of an image Transformer as encoder, and a text Transformer as decoder. The image encoder was initialized from the weights of DeiT, while the text decoder was initialized from the weights of UniLM.

Multimodal Text-to-Video

Hugging Face

Text-to-Video Synthesis

modelscope-damo-text-to-video-synthesis

pipeline('text-to-video-synthesis')

{'text': 'A short text description in English'}

['modelscope==1.4.2', 'open_clip_torch', 'pytorch-lightning']

from huggingface_hub import snapshot_download from modelscope.pipelines import pipeline from modelscope.outputs import OutputKeys import pathlib model_dir = pathlib.Path('weights') snapshot_download('damo-vilab/modelscope-damo-text-to-video-synthesis', repo_type='model', local_dir=model_dir) pipe = pipeline('text-to-video-synthesis', model_dir.as_posix()) test_text = { 'text': 'A panda eating bamboo on a rock.', } output_video_path = pipe(test_text,)[OutputKeys.OUTPUT_VIDEO] print('output_video_path:', output_video_path)

{'dataset': 'Webvid, ImageNet, LAION5B', 'accuracy': 'Not provided'}

This model is based on a multi-stage text-to-video generation diffusion model, which inputs a description text and returns a video that matches the text description. Only English input is supported.

Multimodal Image-to-Text

Hugging Face Transformers

Transformers

mgp-str

MgpstrForSceneTextRecognition.from_pretrained('alibaba-damo/mgp-str-base')

{'model_name': 'alibaba-damo/mgp-str-base'}

{'packages': ['transformers']}

from transformers import MgpstrProcessor, MgpstrForSceneTextRecognition import requests from PIL import Image processor = MgpstrProcessor.from_pretrained('alibaba-damo/mgp-str-base') model = MgpstrForSceneTextRecognition.from_pretrained('alibaba-damo/mgp-str-base') url = https://i.postimg.cc/ZKwLg2Gw/367-14.png image = Image.open(requests.get(url, stream=True).raw).convert(RGB) pixel_values = processor(images=image, return_tensors=pt).pixel_values outputs = model(pixel_values) generated_text = processor.batch_decode(outputs.logits)['generated_text']

{'dataset': 'MJSynth and SynthText', 'accuracy': None}

MGP-STR is a pure vision Scene Text Recognition (STR) model, consisting of ViT and specially designed A^3 modules. It is trained on MJSynth and SynthText datasets and can be used for optical character recognition (OCR) on text images.

Multimodal Text-to-Video

Hugging Face

Text-to-video synthesis

damo-vilab/text-to-video-ms-1.7b

DiffusionPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b')

{'torch_dtype': 'torch.float16', 'variant': 'fp16'}

pip install diffusers transformers accelerate

import torch from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler from diffusers.utils import export_to_video pipe = DiffusionPipeline.from_pretrained(damo-vilab/text-to-video-ms-1.7b, torch_dtype=torch.float16, variant=fp16) pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.enable_model_cpu_offload() prompt = Spiderman is surfing video_frames = pipe(prompt, num_inference_steps=25).frames video_path = export_to_video(video_frames)

{'dataset': 'Webvid, ImageNet, LAION5B', 'accuracy': 'N/A'}

This model is based on a multi-stage text-to-video generation diffusion model, which inputs a description text and returns a video that matches the text description. The model consists of three sub-networks: text feature extraction model, text feature-to-video latent space diffusion model, and video latent space to video visual space model. The overall model parameters are about 1.7 billion. Currently, it only supports English input.

Multimodal Text-to-Video

Hugging Face

Text-to-Video

chavinlo/TempoFunk

pipeline('text-to-video', model='chavinlo/TempoFunk')

['input_text']

['transformers']

{'dataset': '', 'accuracy': ''}

A Text-to-Video model using Hugging Face Transformers library. Model is capable of generating video content based on the input text.

Multimodal Text-to-Video

Hugging Face

Text-to-Video

ImRma/Brucelee

pipeline('text-to-video', model='ImRma/Brucelee')

['your_text']

['transformers']

{'dataset': '', 'accuracy': ''}

A Hugging Face model for converting Persian and English text into video.

Multimodal Text-to-Video

Hugging Face

Text-to-Video

camenduru/text2-video-zero

pipeline('text-to-video', model='camenduru/text2-video-zero')

['input_text']

['transformers']

{'dataset': '', 'accuracy': ''}

This model is used for generating videos from text inputs. It is based on the Hugging Face framework and can be used with the transformers library. The model is trained on a variety of text and video datasets, and can be used for tasks such as video summarization, video generation from text prompts, and more.

Multimodal Text-to-Video

Hugging Face

Text-to-Video Synthesis

damo-vilab/text-to-video-ms-1.7b-legacy

DiffusionPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b-legacy')

['prompt', 'num_inference_steps']

['diffusers', 'transformers', 'accelerate']

import torch from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler from diffusers.utils import export_to_video pipe = DiffusionPipeline.from_pretrained(damo-vilab/text-to-video-ms-1.7b-legacy, torch_dtype=torch.float16) pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.enable_model_cpu_offload() prompt = Spiderman is surfing video_frames = pipe(prompt, num_inference_steps=25).frames video_path = export_to_video(video_frames)

{'dataset': ['LAION5B', 'ImageNet', 'Webvid'], 'accuracy': 'Not provided'}

This model is based on a multi-stage text-to-video generation diffusion model, which inputs a description text and returns a video that matches the text description. Only English input is supported.

Multimodal Text-to-Video

Hugging Face

Text-to-video-synthesis

damo-vilab/text-to-video-ms-1.7b

DiffusionPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b')

['prompt', 'num_inference_steps', 'num_frames']

['pip install git+https://github.com/huggingface/diffusers transformers accelerate']

pipe = DiffusionPipeline.from_pretrained(damo-vilab/text-to-video-ms-1.7b, torch_dtype=torch.float16, variant=fp16) pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.enable_model_cpu_offload() prompt = Spiderman is surfing video_frames = pipe(prompt, num_inference_steps=25).frames video_path = export_to_video(video_frames)

{'dataset': 'Webvid', 'accuracy': 'Not specified'}

A multi-stage text-to-video generation diffusion model that inputs a description text and returns a video that matches the text description. The model consists of three sub-networks: text feature extraction model, text feature-to-video latent space diffusion model, and video latent space to video visual space model. It supports English input only and has a wide range of applications.

Multimodal Text-to-Video

Hugging Face

Text-to-Video

duncan93/video

BaseModel.from_pretrained('duncan93/video')

Asteroid

{'dataset': 'OpenAssistant/oasst1', 'accuracy': ''}

A text-to-video model trained on OpenAssistant/oasst1 dataset.

Multimodal Text-to-Video

Hugging Face

Text-to-Video Generation

mo-di-bear-guitar

TuneAVideoPipeline.from_pretrained('nitrosocke/mo-di-diffusion', unet=UNet3DConditionModel.from_pretrained('Tune-A-Video-library/mo-di-bear-guitar', subfolder='unet'), torch_dtype=torch.float16)

{'prompt': 'string', 'video_length': 'int', 'height': 'int', 'width': 'int', 'num_inference_steps': 'int', 'guidance_scale': 'float'}

['torch', 'tuneavideo']

from tuneavideo.pipelines.pipeline_tuneavideo import TuneAVideoPipeline from tuneavideo.models.unet import UNet3DConditionModel from tuneavideo.util import save_videos_grid import torch pretrained_model_path = nitrosocke/mo-di-diffusion unet_model_path = Tune-A-Video-library/mo-di-bear-guitar unet = UNet3DConditionModel.from_pretrained(unet_model_path, subfolder='unet', torch_dtype=torch.float16).to('cuda') pipe = TuneAVideoPipeline.from_pretrained(pretrained_model_path, unet=unet, torch_dtype=torch.float16).to(cuda) pipe.enable_xformers_memory_efficient_attention() prompt = a magical princess is playing guitar, modern disney style video = pipe(prompt, video_length=8, height=512, width=512, num_inference_steps=50, guidance_scale=7.5).videos save_videos_grid(video, f./{prompt}.gif)

{'dataset': 'Not mentioned', 'accuracy': 'Not mentioned'}

Tune-A-Video is a text-to-video generation model based on the Hugging Face framework. The model generates videos based on textual prompts in a modern Disney style.

Multimodal Text-to-Video

Hugging Face

Text-to-Video Generation

redshift-man-skiing

TuneAVideoPipeline.from_pretrained('nitrosocke/redshift-diffusion', unet=UNet3DConditionModel.from_pretrained('Tune-A-Video-library/redshift-man-skiing', subfolder='unet'))

{'prompt': 'string', 'video_length': 'int', 'height': 'int', 'width': 'int', 'num_inference_steps': 'int', 'guidance_scale': 'float'}

['torch', 'tuneavideo']

from tuneavideo.pipelines.pipeline_tuneavideo import TuneAVideoPipeline from tuneavideo.models.unet import UNet3DConditionModel from tuneavideo.util import save_videos_grid import torch pretrained_model_path = nitrosocke/redshift-diffusion unet_model_path = Tune-A-Video-library/redshift-man-skiing unet = UNet3DConditionModel.from_pretrained(unet_model_path, subfolder='unet', torch_dtype=torch.float16).to('cuda') pipe = TuneAVideoPipeline.from_pretrained(pretrained_model_path, unet=unet, torch_dtype=torch.float16).to(cuda) pipe.enable_xformers_memory_efficient_attention() prompt = (redshift style) spider man is skiing video = pipe(prompt, video_length=8, height=512, width=512, num_inference_steps=50, guidance_scale=7.5).videos save_videos_grid(video, f./{prompt}.gif)

{'dataset': 'N/A', 'accuracy': 'N/A'}

Tune-A-Video - Redshift is a text-to-video generation model based on the nitrosocke/redshift-diffusion model. It generates videos based on textual prompts, such as 'a man is skiing' or '(redshift style) spider man is skiing'.

Multimodal Visual Question Answering

Hugging Face Transformers

Transformers

microsoft/git-base-textvqa

AutoModel.from_pretrained('microsoft/git-base-textvqa')

image, question

transformers

vqa_pipeline({'image': 'path/to/image.jpg', 'question': 'What is in the image?'})

{'dataset': 'TextVQA', 'accuracy': 'Refer to the paper'}

GIT (GenerativeImage2Text), base-sized, fine-tuned on TextVQA. It is a Transformer decoder conditioned on both CLIP image tokens and text tokens. The model is trained using 'teacher forcing' on a lot of (image, text) pairs. The goal for the model is to predict the next text token, giving the image tokens and previous text tokens. It can be used for tasks like image and video captioning, visual question answering (VQA) on images and videos, and even image classification.