domain
stringclasses 40
values | framework
stringclasses 20
values | functionality
stringclasses 181
values | api_name
stringlengths 4
87
| api_call
stringlengths 15
216
| api_arguments
stringlengths 0
495
| python_environment_requirements
stringlengths 0
190
| example_code
stringlengths 0
3.35k
| performance
stringlengths 22
1.36k
| description
stringlengths 35
1.11k
|
---|---|---|---|---|---|---|---|---|---|
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. |
End of preview. Expand
in Dataset Viewer.
README.md exists but content is empty.
Use the Edit dataset card button to edit it.
- Downloads last month
- 0