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 th... |
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-tune... |
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-tune... |
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_pretrain... | {'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_pretrai... | {'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... |
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 var... |
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... |
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_pretra... | {'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 reposit... |
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 ta... |
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_te... | {'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, ... | 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':... | {'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 embe... |
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 = attenti... | {'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.',
]
eng... | {'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': '... | {'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 = 'Wher... | {'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://gith... |
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(a... | {'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 sa... |
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]
im... | {'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).ima... | {'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)\np... | {'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... |
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, je... | {'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... | 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 datase... |
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... | {'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, fil... | {'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=ma... | {'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
... | {'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)
... | {'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, unde... |
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... | {'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 = Ima... | {'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, t... | {'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_pri... | {'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 tr... |
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... | {'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... | {'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 P... |
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 ma... | {'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 word... |
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, ... | {'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_dt... | {'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 pr... |
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 ma... | {'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 Diffus... |
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 = AutoToke... | {'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-upscale... | {'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 su... |
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... | |
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.co... | {'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 rem... |
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 = BlipForConditionalGen... | {'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 filt... |
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 =... | {'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 Transforme... |
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.f... | {'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 ... |
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')
... | {'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(p... | {'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 t... |
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... | {'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 que... |
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-lan... | {'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 answ... |
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')
mo... | {'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 ... |
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_pret... | {'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 ... |
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')
m... | {'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 ... |
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... |
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 n... |
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 ni... |
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/pix2st... | {'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... |
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... |
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 ... | {'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 Transforme... |
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... | {'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 mo... |
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. ... |
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. ... | |
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-s... | {'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. T... |
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')
mode... | {'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 Transforme... |
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... | {'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 =... | {'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.confi... | {'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 vid... |
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.... | {'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
vid... | {'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... |
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 = UNet3DConditionMode... | {'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 = UNet3DConditio... | {'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 t... |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 8