license stringlengths 2 30 | tags stringlengths 2 513 | is_nc bool 1 class | readme_section stringlengths 201 597k | hash stringlengths 32 32 |
|---|---|---|---|---|
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1 | Accuracy | |:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:| | 0.4206 | 1.0 | 692 | 0.2182 | 0.7513 | 0.7757 | 0.7633 | 0.9342 | | 0.1872 | 2.0 | 1384 | 0.2032 | 0.7779 | 0.7865 | 0.7821 | 0.9398 | | 0.0982 | 3.0 | 2076 | 0.2043 | 0.7995 | 0.7904 | 0.7949 | 0.9443 | | 0.0735 | 4.0 | 2768 | 0.2217 | 0.7936 | 0.8067 | 0.8001 | 0.9451 | | 423ae2e891c461df921398c375579e50 |
apache-2.0 | [] | false | Model description Tk-Instruct is a series of encoder-decoder Transformer models that are trained to solve various NLP tasks by following in-context instructions (plain language task definitions, k-shot examples, explanations, etc). Built upon the pre-trained [T5 models](https://arxiv.org/abs/1910.10683), they are fine-tuned on a large number of tasks & instructions that are collected in the [Natural Instructions benchmark](https://github.com/allenai/natural-instructions), which contains 1600+ tasks in 70+ broach categories in total. This enables the model to not only process the training tasks, but also generalize to many unseen tasks without further parameter update. More resources for using the model: - **Paper**: [link](https://arxiv.org/abs/2204.07705) - **Code repository**: [Tk-Instruct](https://github.com/yizhongw/Tk-Instruct) - **Official Website**: [Natural Instructions](https://instructions.apps.allenai.org/) - **All released models**: [allenai/tk-instruct](https://huggingface.co/models?search=allenai/tk-instruct) | 8c84567a5c7699cdd2bcf26749e45b47 |
apache-2.0 | [] | false | How to use When instructing the model, task definition or demonstration examples or explanations should be prepended to the original input and fed into the model. You can easily try Tk-Instruct models as follows: ```python >>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM >>> tokenizer = AutoTokenizer.from_pretrained("allenai/tk-instruct-3b-def") >>> model = AutoModelForSeq2SeqLM.from_pretrained("allenai/tk-instruct-3b-def") >>> input_ids = tokenizer.encode( "Definition: return the currency of the given country. Now complete the following example - Input: India. Output:", return_tensors="pt") >>> output = model.generate(input_ids, max_length=10) >>> output = tokenizer.decode(output[0], skip_special_tokens=True) | 6480012f8c1425460475930405c61d12 |
apache-2.0 | [] | false | model should output 'Indian Rupee' >>> input_ids = tokenizer.encode( "Definition: negate the following sentence. Input: John went to school. Output:", return_tensors="pt") >>> output = model.generate(input_ids, max_length=10) >>> output = tokenizer.decode(output[0], skip_special_tokens=True) | 89d4dfd9ac93395d94ced34be6bcb646 |
apache-2.0 | [] | false | Limitations We are still working on understanding the behaviors of these models, but here are several issues we have found: - Models are generally sensitive to the instruction. Sometimes rewording the instruction can lead to very different output. - Models are not always compliant to the instruction. Sometimes the model don't follow your instruction (e.g., when you ask the model to generate one sentence, it might still generate one word or a long story). - Models might totally fail on some tasks. If you find serious issues or any interesting result, you are welcome to share with us! | 55b8be3ffd4d7157ff90db91f3d4c673 |
apache-2.0 | [] | false | Training data Tk-Instruct is trained using the tasks & instructions in [Natural Instructions benchmark](https://github.com/allenai/natural-instructions), which contains 1600+ tasks in 70+ broach categories in total. We follow the official train/test split. Tk-Instruct model series were trained using 757 tasks, and mTk-Instruct series were trained using 1271 tasks (including some non-English tasks). The training tasks are in 64 broad categories, such as text categorization / question answering / sentiment analysis / summarization / grammar error detection / dialogue generation / etc. The other 12 categories are selected for evaluation. | 0c1910a8c972c7d769ff993f0a8ad3d4 |
apache-2.0 | [] | false | Training procedure All our models are initialized from either T5 models or mT5 models. Because generating the output can be regarded as a form of language modeling, we used their [LM adapted version](https://github.com/google-research/text-to-text-transfer-transformer/blob/main/released_checkpoints.md | e4225bb5328e990dc5e7631b4e5452fa |
apache-2.0 | [] | false | lm-adapted-t511lm100k). All data is converted into a text-to-text format, and models are fine-tuned to maximize the likelihood of the output sequence. Our [released models](https://huggingface.co/models?search=allenai/tk-instruct) are in different sizes, and each of them was trained with a specific type of instruction encoding. For instance, `tk-instruct-3b-def-pos` was initialized from [t5-xl-lm-adapt](https://huggingface.co/google/t5-xl-lm-adapt), and it saw task definition & 2 positive examples as the instruction during training time. Although they are trained with only one type of instruction encodings, we found they can usually work with other type of encodings at test time (see more in our paper). | a5533ee965d1e8cd974ccb05cd80b4a0 |
apache-2.0 | [] | false | BibTeX entry and citation info ```bibtex @article{wang2022benchmarking, title={Benchmarking Generalization via In-Context Instructions on 1,600+ Language Tasks}, author={Yizhong Wang and Swaroop Mishra and Pegah Alipoormolabashi and Yeganeh Kordi and Amirreza Mirzaei and A. Arunkumar and Arjun Ashok and Arut Selvan Dhanasekaran and Atharva Naik and David Stap and Eshaan Pathak and Giannis Karamanolakis and Haizhi Gary Lai and Ishan Purohit and Ishani Mondal and Jacob Anderson and Kirby Kuznia and Krima Doshi and Maitreya Patel and Kuntal Kumar Pal and M. Moradshahi and Mihir Parmar and Mirali Purohit and Neeraj Varshney and Phani Rohitha Kaza and Pulkit Verma and Ravsehaj Singh Puri and Rushang Karia and Shailaja Keyur Sampat and Savan Doshi and Siddharth Deepak Mishra and Sujan C. Reddy and Sumanta Patro and Tanay Dixit and Xu-dong Shen and Chitta Baral and Yejin Choi and Hannaneh Hajishirzi and Noah A. Smith and Daniel Khashabi}, year={2022}, archivePrefix={arXiv}, eprint={2204.07705}, primaryClass={cs.CL}, } ``` | 7be3624fc5cc92a0a8c423c234dac4b2 |
mit | [] | false | 4tNGHT on Stable Diffusion This is the `<4tNGHT>` concept taught to Stable Diffusion via Textual Inversion. You can load this concept into the [Stable Conceptualizer](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/stable_conceptualizer_inference.ipynb) notebook. You can also train your own concepts and load them into the concept libraries using [this notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/sd_textual_inversion_training.ipynb). Here is the new concept you will be able to use as a `style`:                                                                                                          | 6c082a3334f2b9f365e9562cd8ea6702 |
apache-2.0 | ['whisper-event', 'generated_from_trainer'] | false | Whisper Small Portuguese This model is a fine-tuned version of [openai/whisper-small](https://huggingface.co/openai/whisper-small) on the mozilla-foundation/common_voice_11_0 pt dataset. It achieves the following results on the evaluation set: - Loss: 0.3056 - Wer: 14.6841 - Cer: 5.8856 | 965efa9183c2ccd3fa68cd7789e9cedc |
apache-2.0 | ['whisper-event', 'generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-06 - train_batch_size: 32 - eval_batch_size: 16 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - lr_scheduler_warmup_steps: 1000 - training_steps: 10000 - mixed_precision_training: Native AMP | 8a2cf54218ca5e026122267fa7aca336 |
apache-2.0 | ['whisper-event', 'generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Wer | Cer | |:-------------:|:-----:|:----:|:---------------:|:-------:|:------:| | 0.2817 | 0.92 | 500 | 0.3352 | 15.9476 | 6.3609 | | 0.2245 | 1.84 | 1000 | 0.3047 | 15.0231 | 5.9326 | | 0.1587 | 2.76 | 1500 | 0.2985 | 15.0847 | 5.9326 | | 0.1181 | 3.68 | 2000 | 0.3056 | 14.6841 | 5.8856 | | 0.0741 | 4.6 | 2500 | 0.3162 | 14.9923 | 5.9906 | | 0.0438 | 5.52 | 3000 | 0.3466 | 15.4700 | 6.2255 | | 0.0294 | 6.45 | 3500 | 0.3799 | 15.2234 | 6.1647 | | 918e193e2caba669bb5743621fe9c177 |
apache-2.0 | ['generated_from_trainer'] | false | vit-base-patch16-224-in21k_car_or_motorcycle This model is a fine-tuned version of [google/vit-base-patch16-224-in21k](https://huggingface.co/google/vit-base-patch16-224-in21k) on the imagefolder dataset. It achieves the following results on the evaluation set: - Loss: 0.0301 - Accuracy: 0.9938 - Weighted f1: 0.9939 - Weighted recall: 0.9927 - Weighted precision: 0.9951 | 8e65418e571ea371cb5451bb331ab174 |
apache-2.0 | ['generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 0.0002 - train_batch_size: 16 - eval_batch_size: 8 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 2 | 811561861be64e682992d16feacd7b62 |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Accuracy | Weighted f1 | Weighted recall | Weighted precision | |:-------------:|:-----:|:----:|:---------------:|:--------:|:-----------:|:---------------:|:------------------:| | 0.6908 | 1.0 | 200 | 0.0372 | 0.99 | 0.9902 | 0.9902 | 0.9902 | | 0.6908 | 2.0 | 400 | 0.0301 | 0.9938 | 0.9939 | 0.9927 | 0.9951 | | b0f8fe6acec03f17bc3a7ee941a3d10c |
apache-2.0 | ['generated_from_trainer'] | false | rule_learning_margin_1mm This model is a fine-tuned version of [bert-base-uncased](https://huggingface.co/bert-base-uncased) on the enoriega/odinsynth_dataset dataset. It achieves the following results on the evaluation set: - Loss: 0.3806 - Margin Accuracy: 0.8239 | 6d10a135e6fe90330d0b2550f2a4c901 |
apache-2.0 | ['generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - train_batch_size: 4 - eval_batch_size: 4 - seed: 42 - gradient_accumulation_steps: 2000 - total_train_batch_size: 8000 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 3.0 - mixed_precision_training: Native AMP | 4a659f0c329d30b4c5b4132bea67765b |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Margin Accuracy | |:-------------:|:-----:|:----:|:---------------:|:---------------:| | 0.6482 | 0.16 | 20 | 0.6494 | 0.7263 | | 0.5151 | 0.32 | 40 | 0.5088 | 0.7792 | | 0.4822 | 0.48 | 60 | 0.4429 | 0.8045 | | 0.4472 | 0.64 | 80 | 0.4265 | 0.8107 | | 0.4352 | 0.8 | 100 | 0.4155 | 0.8132 | | 0.4335 | 0.96 | 120 | 0.4128 | 0.8116 | | 0.4113 | 1.12 | 140 | 0.4119 | 0.8142 | | 0.4186 | 1.28 | 160 | 0.4075 | 0.8120 | | 0.42 | 1.44 | 180 | 0.4072 | 0.8123 | | 0.4175 | 1.6 | 200 | 0.4080 | 0.8130 | | 0.4097 | 1.76 | 220 | 0.4031 | 0.8128 | | 0.397 | 1.92 | 240 | 0.4004 | 0.8130 | | 0.4115 | 2.08 | 260 | 0.3979 | 0.8136 | | 0.4108 | 2.24 | 280 | 0.3940 | 0.8167 | | 0.4125 | 2.4 | 300 | 0.3879 | 0.8218 | | 0.4117 | 2.56 | 320 | 0.3848 | 0.8217 | | 0.3967 | 2.72 | 340 | 0.3818 | 0.8231 | | 0.3947 | 2.88 | 360 | 0.3813 | 0.8240 | | e829875e59b544ed86b7f2bafa3d7f1f |
creativeml-openrail-m | ['stable-diffusion', 'stable-diffusion-diffusers', 'text-to-image'] | false | PyTorch ```bash pip install --upgrade diffusers transformers scipy ``` Run this command to log in with your HF Hub token if you haven't before: ```bash huggingface-cli login ``` Running the pipeline with the default PNDM scheduler: ```python 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, revision="fp16") 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") ``` **Note**: If you are limited by GPU memory and have less than 4GB of GPU RAM available, please make sure to load the StableDiffusionPipeline in float16 precision instead of the default float32 precision as done above. You can do so by telling diffusers to expect the weights to be in float16 precision: ```py import torch pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16, revision="fp16") pipe = pipe.to(device) pipe.enable_attention_slicing() prompt = "a photo of an astronaut riding a horse on mars" image = pipe(prompt).images[0] image.save("astronaut_rides_horse.png") ``` To swap out the noise scheduler, pass it to `from_pretrained`: ```python from diffusers import StableDiffusionPipeline, EulerDiscreteScheduler model_id = "CompVis/stable-diffusion-v1-4" | e8e581678a8f7028ce6ecac9d0e82a0d |
creativeml-openrail-m | ['stable-diffusion', 'stable-diffusion-diffusers', 'text-to-image'] | false | Use the Euler scheduler here instead scheduler = EulerDiscreteScheduler.from_pretrained(model_id, subfolder="scheduler") pipe = StableDiffusionPipeline.from_pretrained(model_id, scheduler=scheduler, torch_dtype=torch.float16, revision="fp16") 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") ``` | 72c79cc963712d2f8913dd2747460865 |
creativeml-openrail-m | ['stable-diffusion', 'stable-diffusion-diffusers', 'text-to-image'] | false | JAX/Flax To use StableDiffusion on TPUs and GPUs for faster inference you can leverage JAX/Flax. Running the pipeline with default PNDMScheduler ```python import jax import numpy as np from flax.jax_utils import replicate from flax.training.common_utils import shard from diffusers import FlaxStableDiffusionPipeline pipeline, params = FlaxStableDiffusionPipeline.from_pretrained( "CompVis/stable-diffusion-v1-4", revision="flax", dtype=jax.numpy.bfloat16 ) prompt = "a photo of an astronaut riding a horse on mars" prng_seed = jax.random.PRNGKey(0) num_inference_steps = 50 num_samples = jax.device_count() prompt = num_samples * [prompt] prompt_ids = pipeline.prepare_inputs(prompt) | c67511e8b76848b65becf036adbe99d1 |
creativeml-openrail-m | ['stable-diffusion', 'stable-diffusion-diffusers', 'text-to-image'] | false | shard inputs and rng params = replicate(params) prng_seed = jax.random.split(prng_seed, 8) prompt_ids = shard(prompt_ids) images = pipeline(prompt_ids, params, prng_seed, num_inference_steps, jit=True).images images = pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:]))) ``` **Note**: If you are limited by TPU memory, please make sure to load the `FlaxStableDiffusionPipeline` in `bfloat16` precision instead of the default `float32` precision as done above. You can do so by telling diffusers to load the weights from "bf16" branch. ```python import jax import numpy as np from flax.jax_utils import replicate from flax.training.common_utils import shard from diffusers import FlaxStableDiffusionPipeline pipeline, params = FlaxStableDiffusionPipeline.from_pretrained( "CompVis/stable-diffusion-v1-4", revision="bf16", dtype=jax.numpy.bfloat16 ) prompt = "a photo of an astronaut riding a horse on mars" prng_seed = jax.random.PRNGKey(0) num_inference_steps = 50 num_samples = jax.device_count() prompt = num_samples * [prompt] prompt_ids = pipeline.prepare_inputs(prompt) | cc242e4d17bec2edb3c9988ee65769b6 |
creativeml-openrail-m | ['stable-diffusion', 'stable-diffusion-diffusers', 'text-to-image'] | false | shard inputs and rng params = replicate(params) prng_seed = jax.random.split(prng_seed, 8) prompt_ids = shard(prompt_ids) images = pipeline(prompt_ids, params, prng_seed, num_inference_steps, jit=True).images images = pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:]))) ``` | 2f49a23fb151e9920d2a74855dbe8972 |
mit | [] | false | Model Description A series of CLIP [ConvNeXt-Base](https://arxiv.org/abs/2201.03545) (w/ wide embed dim) models trained on subsets LAION-5B (https://laion.ai/blog/laion-5b/) using OpenCLIP (https://github.com/mlfoundations/open_clip). Goals: * Explore an alternative to ViT and ResNet (w/ AttentionPooling) CLIP models that scales well with model size and image resolution Firsts: * First known ConvNeXt CLIP models trained at scale in the range of CLIP ViT-B/16 and RN50x4 models * First released model weights exploring increase of augmentation + regularization for image tower via adding (greater scale range of RRC, random erasing, stochastic depth) The models utilize the [timm](https://github.com/rwightman/pytorch-image-models) ConvNeXt-Base model (`convnext_base`) as the image tower, and the same text tower as the RN50x4 (depth 12, embed dim 640) model from OpenAI CLIP. The base models are trained at 256x256 image resolution and roughly match the RN50x4 models on FLOPs and activation counts. The models with `320` in the name are trained at 320x320. All models in this series were trained for 13B samples and have ImageNet Zero-Shot top-1 of >= 70.8%. Comparing to ViT-B/16 at 34B SS with zero-shot of 70.2% (68.1% for 13B SS) this suggests the ConvNeXt architecture may be more sample efficient in this range of model scale. More experiments needed to confirm. | Model | Dataset | Resolution | AugReg | Top-1 ImageNet Zero-Shot (%) | | ----- | ------- | ---------- | ------------ | --------- | | [convnext_base_w.laion2b_s13b_b82k](https://huggingface.co/laion/CLIP-convnext_base_w-laion2B-s13B-b82K) | LAION-2B | 256x256 | RRC (0.9, 1.0) | 70.8 | | [convnext_base_w.laion2b_s13b_b82k_augreg](https://huggingface.co/laion/CLIP-convnext_base_w-laion2B-s13B-b82K-augreg) | LAION-2B | 256x256 | RRC (0.33, 1.0), RE (0.35), SD (0.1) | 71.5 | | [convnext_base_w.laion_aesthetic_s13b_b82k](https://huggingface.co/laion/CLIP-convnext_base_w-laion_aesthetic-s13B-b82K) | LAION-A | 256x256 | RRC (0.9, 1.0) | 71.0 | | [convnext_base_w_320.laion_aesthetic_s13b_b82k](https://huggingface.co/laion/CLIP-convnext_base_w_320-laion_aesthetic-s13B-b82K) | LAION-A | 320x320 | RRC (0.9, 1.0) | 71.7 | | [convnext_base_w_320.laion_aesthetic_s13b_b82k_augreg](https://huggingface.co/laion/CLIP-convnext_base_w_320-laion_aesthetic-s13B-b82K-augreg) | LAION-A | 320x320 | RRC (0.33, 1.0), RE (0.35), SD (0.1) | 71.3 | RRC = Random Resize Crop (crop pcts), RE = Random Erasing (prob), SD = Stochastic Depth (prob) -- image tower only LAION-A = LAION Aesthetic, an ~900M sample subset of LAION-2B with pHash dedupe and asthetic score filtering. Model training done by Ross Wightman across both the [stability.ai](https://stability.ai/) cluster and the [JUWELS Booster](https://apps.fz-juelich.de/jsc/hps/juwels/booster-overview.html) supercomputer. See acknowledgements below. | 170211e7758fd3d1799eddbaf47fe88e |
mit | [] | false | Uses As per the original [OpenAI CLIP model card](https://github.com/openai/CLIP/blob/d50d76daa670286dd6cacf3bcd80b5e4823fc8e1/model-card.md), this model is intended as a research output for research communities. We hope that this model will enable researchers to better understand and explore zero-shot, arbitrary image classification. We also hope it can be used for interdisciplinary studies of the potential impact of such model. The OpenAI CLIP paper includes a discussion of potential downstream impacts to provide an example for this sort of analysis. Additionally, the LAION-5B blog (https://laion.ai/blog/laion-5b/) and upcoming paper include additional discussion as it relates specifically to the training dataset. | aae0c0cfa4d00f065bf8846d50d6ab17 |
mit | [] | false | Out-of-Scope Use As per the OpenAI models, **Any** deployed use case of the model - whether commercial or not - is currently out of scope. Non-deployed use cases such as image search in a constrained environment, are also not recommended unless there is thorough in-domain testing of the model with a specific, fixed class taxonomy. This is because our safety assessment demonstrated a high need for task specific testing especially given the variability of CLIP’s performance with different class taxonomies. This makes untested and unconstrained deployment of the model in any use case currently potentially harmful. Certain use cases which would fall under the domain of surveillance and facial recognition are always out-of-scope regardless of performance of the model. This is because the use of artificial intelligence for tasks such as these can be premature currently given the lack of testing norms and checks to ensure its fair use. Since the model has not been purposefully trained in or evaluated on any languages other than English, its use should be limited to English language use cases. Further the above notice, the LAION-5B dataset used in training of these models has additional considerations, see below. | f3dc3a51068b74d0b26844d7a0c3d4d5 |
mit | [] | false | Training Data This model was trained with one of (see table in intro): * LAION-2B - A 2 billion sample English subset of LAION-5B (https://laion.ai/blog/laion-5b/). * LAION-Aesthetic - A 900M sample subset of LAION-2B with pHash dedupe and asthetic score filtering **IMPORTANT NOTE:** The motivation behind dataset creation is to democratize research and experimentation around large-scale multi-modal model training and handling of uncurated, large-scale datasets crawled from publically available internet. Our recommendation is therefore to use the dataset for research purposes. Be aware that this large-scale dataset is uncurated. Keep in mind that the uncurated nature of the dataset means that collected links may lead to strongly discomforting and disturbing content for a human viewer. Therefore, please use the demo links with caution and at your own risk. It is possible to extract a “safe” subset by filtering out samples based on the safety tags (using a customized trained NSFW classifier that we built). While this strongly reduces the chance for encountering potentially harmful content when viewing, we cannot entirely exclude the possibility for harmful content being still present in safe mode, so that the warning holds also there. We think that providing the dataset openly to broad research and other interested communities will allow for transparent investigation of benefits that come along with training large-scale models as well as pitfalls and dangers that may stay unreported or unnoticed when working with closed large datasets that remain restricted to a small community. Providing our dataset openly, we however do not recommend using it for creating ready-to-go industrial products, as the basic research about general properties and safety of such large-scale models, which we would like to encourage with this release, is still in progress. | da4c5520eeb1490be85e2fc5aa56ad8b |
mit | [] | false | Training Procedure All models were trained with a global batch size of 81920 for 64 checkpoint intervals of 203.7M samples for a total of ~13B samples seen over training. For 256x256 models, a slurm script w/ srun below was used on 20 8-GPU (A100 40GB) nodes (Stability), switching to 40 4-GPU nodes for time on JUWELS. ``` /opt/slurm/sbin/srun --cpu_bind=v --accel-bind=gn python -m training.main \ --save-frequency 1 \ --name "convnext_256" \ --resume 'latest' \ --train-data="pipe:aws s3 cp s3://mybucket/path/{laion{00000..xxxxx}.tar -" \ --train-num-samples 203666042 \ --dataset-type webdataset \ --precision amp_bfloat16 \ --warmup 10000 \ --batch-size=512 \ --epochs=64 \ --dataset-resampled \ --clip-grad-norm 5.0 \ --lr 1e-3 \ --workers=6 \ --model "convnext_base_w" \ --seed 0 \ --ddp-static-graph \ --local-loss \ --gather-with-grad \ --grad-checkpointing ``` For 320x320 models, same as above but w/ 32 8-GPU nodes, local batch size 320, or 64 4-GPU nodes on JUWELs. | 0d2352ba0a7b84239f8840d02d085766 |
mit | [] | false | Results The models achieve between 70.8 and 71.7 zero-shot top-1 accuracy on ImageNet-1k.  An initial round of benchmarks have been performed on a wider range of datasets, to be viewable at https://github.com/LAION-AI/CLIP_benchmark/blob/main/benchmark/results.ipynb As part of exploring increased augmentation + regularization, early evalations suggest that `augreg` trained models evaluate well over a wider range of resolutions. This is especially true for the 320x320 LAION-A model, where the augreg run was lower than the non-augreg when evaluated at the train resolution of 320x320 (71.3 vs 71.7), but improves to 72.2 when evaluated at 384x384 (the non-augreg drops to 71.0 at 384x384). | 5bfb11361131873097635f7be44ef356 |
mit | [] | false | Acknowledgements Acknowledging [stability.ai](https://stability.ai/) and the Gauss Centre for Supercomputing e.V. (http://gauss-centre.eu) for funding this part of work by providing computing time through the John von Neumann Institute for Computing (NIC) on the GCS Supercomputer JUWELS Booster at Jülich Supercomputing Centre (JSC). | d1dca4f71e192578789beca8e0ff9583 |
mit | [] | false | Citation **BibTeX:** LAION-5B ```bibtex @inproceedings{schuhmann2022laionb, title={{LAION}-5B: An open large-scale dataset for training next generation image-text models}, author={Christoph Schuhmann and Romain Beaumont and Richard Vencu and Cade W Gordon and Ross Wightman and Mehdi Cherti and Theo Coombes and Aarush Katta and Clayton Mullis and Mitchell Wortsman and Patrick Schramowski and Srivatsa R Kundurthy and Katherine Crowson and Ludwig Schmidt and Robert Kaczmarczyk and Jenia Jitsev}, booktitle={Thirty-sixth Conference on Neural Information Processing Systems Datasets and Benchmarks Track}, year={2022}, url={https://openreview.net/forum?id=M3Y74vmsMcY} } ``` OpenCLIP software ```bibtex @software{ilharco_gabriel_2021_5143773, author = {Ilharco, Gabriel and Wortsman, Mitchell and Wightman, Ross and Gordon, Cade and Carlini, Nicholas and Taori, Rohan and Dave, Achal and Shankar, Vaishaal and Namkoong, Hongseok and Miller, John and Hajishirzi, Hannaneh and Farhadi, Ali and Schmidt, Ludwig}, title = {OpenCLIP}, month = jul, year = 2021, note = {If you use this software, please cite it as below.}, publisher = {Zenodo}, version = {0.1}, doi = {10.5281/zenodo.5143773}, url = {https://doi.org/10.5281/zenodo.5143773} } ``` OpenAI CLIP paper ```bibtex @inproceedings{Radford2021LearningTV, title={Learning Transferable Visual Models From Natural Language Supervision}, author={Alec Radford and Jong Wook Kim and Chris Hallacy and A. Ramesh and Gabriel Goh and Sandhini Agarwal and Girish Sastry and Amanda Askell and Pamela Mishkin and Jack Clark and Gretchen Krueger and Ilya Sutskever}, booktitle={ICML}, year={2021} } ``` ```bibtex @Article{liu2022convnet, author = {Zhuang Liu and Hanzi Mao and Chao-Yuan Wu and Christoph Feichtenhofer and Trevor Darrell and Saining Xie}, title = {A ConvNet for the 2020s}, journal = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)}, year = {2022}, } ``` ```bibtex @misc{rw2019timm, author = {Ross Wightman}, title = {PyTorch Image Models}, year = {2019}, publisher = {GitHub}, journal = {GitHub repository}, doi = {10.5281/zenodo.4414861}, howpublished = {\url{https://github.com/rwightman/pytorch-image-models}} } ``` | 57381a1c5147f36b02f564bb13d22b0f |
apache-2.0 | ['text-classification', 'generated_from_trainer'] | false | SPECTER-finetuned-DAGPap22 This model is a fine-tuned version of [allenai/specter](https://huggingface.co/allenai/specter) on an unknown dataset. It achieves the following results on the evaluation set: - Loss: 0.0023 - Accuracy: 0.9993 - F1: 0.9995 | aff565f115cb21d5fa74cc8c0c106284 |
apache-2.0 | ['text-classification', 'generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 6e-06 - train_batch_size: 8 - eval_batch_size: 8 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - lr_scheduler_warmup_steps: 50 - num_epochs: 20 - mixed_precision_training: Native AMP | a9a2f5b264e511ad1afacc1a83a8ddbb |
apache-2.0 | ['text-classification', 'generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Accuracy | F1 | |:-------------:|:-----:|:-----:|:---------------:|:--------:|:------:| | 0.3422 | 1.0 | 669 | 0.4135 | 0.8914 | 0.9140 | | 0.1074 | 2.0 | 1338 | 0.1216 | 0.9746 | 0.9811 | | 0.0329 | 3.0 | 2007 | 0.0064 | 0.9989 | 0.9992 | | 0.0097 | 4.0 | 2676 | 0.0132 | 0.9972 | 0.9980 | | 0.0123 | 5.0 | 3345 | 0.0231 | 0.9961 | 0.9971 | | 0.0114 | 6.0 | 4014 | 0.0080 | 0.9985 | 0.9989 | | 0.0029 | 7.0 | 4683 | 0.2207 | 0.9727 | 0.9797 | | 0.0075 | 8.0 | 5352 | 0.0145 | 0.9974 | 0.9981 | | 0.0098 | 9.0 | 6021 | 0.0047 | 0.9994 | 0.9996 | | 0.0025 | 10.0 | 6690 | 0.0000 | 1.0 | 1.0 | | 0.0044 | 11.0 | 7359 | 0.0035 | 0.9993 | 0.9995 | | 0.0 | 12.0 | 8028 | 0.0027 | 0.9996 | 0.9997 | | 0.0027 | 13.0 | 8697 | 0.0036 | 0.9993 | 0.9995 | | 0.0055 | 14.0 | 9366 | 0.0017 | 0.9998 | 0.9999 | | 0.0 | 15.0 | 10035 | 0.0000 | 1.0 | 1.0 | | 0.0 | 16.0 | 10704 | 0.0000 | 1.0 | 1.0 | | 0.0022 | 17.0 | 11373 | 0.0111 | 0.9981 | 0.9986 | | 0.0004 | 18.0 | 12042 | 0.0011 | 0.9994 | 0.9996 | | 0.0 | 19.0 | 12711 | 0.0020 | 0.9994 | 0.9996 | | 0.0 | 20.0 | 13380 | 0.0023 | 0.9993 | 0.9995 | | 1fe2715c19830dc72933bcbfbfc9805e |
mit | ['generated_from_trainer'] | false | Sentiment140_roBERTa_5E This model is a fine-tuned version of [roberta-base](https://huggingface.co/roberta-base) on the sentiment140 dataset. It achieves the following results on the evaluation set: - Loss: 0.4796 - Accuracy: 0.8933 | 240b81f3682eafed31ad44b827e18890 |
mit | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Accuracy | |:-------------:|:-----:|:----:|:---------------:|:--------:| | 0.699 | 0.08 | 50 | 0.6734 | 0.5467 | | 0.6099 | 0.16 | 100 | 0.4322 | 0.8 | | 0.4906 | 0.24 | 150 | 0.3861 | 0.84 | | 0.4652 | 0.32 | 200 | 0.4288 | 0.7933 | | 0.4874 | 0.4 | 250 | 0.3872 | 0.84 | | 0.4735 | 0.48 | 300 | 0.3401 | 0.8667 | | 0.3909 | 0.56 | 350 | 0.3484 | 0.84 | | 0.4277 | 0.64 | 400 | 0.3207 | 0.88 | | 0.3894 | 0.72 | 450 | 0.3310 | 0.8733 | | 0.4523 | 0.8 | 500 | 0.3389 | 0.8667 | | 0.4087 | 0.88 | 550 | 0.3515 | 0.8467 | | 0.3973 | 0.96 | 600 | 0.3513 | 0.8467 | | 0.4016 | 1.04 | 650 | 0.3501 | 0.8667 | | 0.3613 | 1.12 | 700 | 0.3327 | 0.8667 | | 0.343 | 1.2 | 750 | 0.3518 | 0.86 | | 0.314 | 1.28 | 800 | 0.3555 | 0.88 | | 0.3407 | 1.36 | 850 | 0.3849 | 0.86 | | 0.2944 | 1.44 | 900 | 0.3576 | 0.8667 | | 0.3267 | 1.52 | 950 | 0.3461 | 0.8733 | | 0.3251 | 1.6 | 1000 | 0.3411 | 0.8667 | | 0.321 | 1.68 | 1050 | 0.3371 | 0.88 | | 0.3057 | 1.76 | 1100 | 0.3322 | 0.88 | | 0.3335 | 1.84 | 1150 | 0.3106 | 0.8667 | | 0.3363 | 1.92 | 1200 | 0.3158 | 0.8933 | | 0.2972 | 2.0 | 1250 | 0.3122 | 0.88 | | 0.2453 | 2.08 | 1300 | 0.3327 | 0.8867 | | 0.2467 | 2.16 | 1350 | 0.3767 | 0.8667 | | 0.273 | 2.24 | 1400 | 0.3549 | 0.8667 | | 0.2672 | 2.32 | 1450 | 0.3470 | 0.88 | | 0.2352 | 2.4 | 1500 | 0.4092 | 0.8667 | | 0.2763 | 2.48 | 1550 | 0.3472 | 0.9 | | 0.2858 | 2.56 | 1600 | 0.3440 | 0.9 | | 0.2206 | 2.64 | 1650 | 0.3770 | 0.88 | | 0.2928 | 2.72 | 1700 | 0.3280 | 0.8867 | | 0.2478 | 2.8 | 1750 | 0.3426 | 0.8867 | | 0.2362 | 2.88 | 1800 | 0.3578 | 0.8933 | | 0.2107 | 2.96 | 1850 | 0.3986 | 0.8933 | | 0.2191 | 3.04 | 1900 | 0.3819 | 0.8933 | | 0.2267 | 3.12 | 1950 | 0.4047 | 0.8867 | | 0.2076 | 3.2 | 2000 | 0.4303 | 0.8867 | | 0.1868 | 3.28 | 2050 | 0.4385 | 0.8933 | | 0.2239 | 3.36 | 2100 | 0.4175 | 0.8933 | | 0.2082 | 3.44 | 2150 | 0.4142 | 0.8933 | | 0.2423 | 3.52 | 2200 | 0.4002 | 0.8867 | | 0.1878 | 3.6 | 2250 | 0.4662 | 0.88 | | 0.1892 | 3.68 | 2300 | 0.4783 | 0.88 | | 0.2259 | 3.76 | 2350 | 0.4487 | 0.88 | | 0.1859 | 3.84 | 2400 | 0.4456 | 0.8933 | | 0.2042 | 3.92 | 2450 | 0.4468 | 0.8933 | | 0.2096 | 4.0 | 2500 | 0.4153 | 0.8867 | | 0.178 | 4.08 | 2550 | 0.4100 | 0.8933 | | 0.1621 | 4.16 | 2600 | 0.4292 | 0.8933 | | 0.1682 | 4.24 | 2650 | 0.4602 | 0.8933 | | 0.1813 | 4.32 | 2700 | 0.4680 | 0.8933 | | 0.2033 | 4.4 | 2750 | 0.4735 | 0.8933 | | 0.1662 | 4.48 | 2800 | 0.4750 | 0.88 | | 0.1686 | 4.56 | 2850 | 0.4830 | 0.8933 | | 0.1603 | 4.64 | 2900 | 0.4909 | 0.8933 | | 0.148 | 4.72 | 2950 | 0.4784 | 0.8933 | | 0.162 | 4.8 | 3000 | 0.4750 | 0.8867 | | 0.153 | 4.88 | 3050 | 0.4759 | 0.8867 | | 0.1657 | 4.96 | 3100 | 0.4796 | 0.8933 | | e14266e32a8476ce1b762c77268a47b5 |
mit | ['generated_from_trainer'] | false | m2m100_418M-evaluated-en-to-ar-2000instancesopus-leaningRate2e-05-batchSize16-20epoch-1 This model is a fine-tuned version of [facebook/m2m100_418M](https://huggingface.co/facebook/m2m100_418M) on the opus100 dataset. It achieves the following results on the evaluation set: - Loss: 0.3640 - Bleu: 13.1835 - Meteor: 0.1189 - Gen Len: 17.72 | d657251a5d13e845e8fb8ba8fe2f8413 |
mit | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Bleu | Meteor | Gen Len | |:-------------:|:-----:|:----:|:---------------:|:-------:|:------:|:-------:| | 6.1776 | 1.0 | 100 | 3.8904 | 10.5866 | 0.0995 | 16.64 | | 2.4531 | 2.0 | 200 | 1.0928 | 12.3452 | 0.1108 | 17.0575 | | 0.512 | 3.0 | 300 | 0.3625 | 10.5224 | 0.0982 | 17.2575 | | 0.1924 | 4.0 | 400 | 0.3342 | 12.4242 | 0.1098 | 16.6325 | | 0.1227 | 5.0 | 500 | 0.3403 | 13.0526 | 0.1185 | 17.3475 | | 0.0889 | 6.0 | 600 | 0.3481 | 13.1323 | 0.1133 | 17.815 | | 0.0651 | 7.0 | 700 | 0.3601 | 12.6684 | 0.1133 | 17.3525 | | 0.0533 | 8.0 | 800 | 0.3640 | 13.1835 | 0.1189 | 17.72 | | 1978157869efbcd5262c752e3e38a0f2 |
apache-2.0 | ['whisper-event', 'generated_from_trainer'] | false | Whisper Large-v2 Maltese This model is a fine-tuned version of [openai/whisper-large-v2](https://huggingface.co/openai/whisper-large-v2) on the mozilla-foundation/common_voice_11_0 mt dataset. It achieves the following results on the evaluation set: - Loss: 0.3616 - Wer: 18.4644 | e698c1ba837887c28e8075347e552976 |
apache-2.0 | ['whisper-event', 'generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 1e-05 - train_batch_size: 32 - eval_batch_size: 16 - seed: 42 - distributed_type: multi-GPU - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - lr_scheduler_warmup_steps: 100 - training_steps: 1000 | 49fc4d72ba482475384dc6f6918d7761 |
apache-2.0 | ['whisper-event', 'generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Wer | |:-------------:|:-----:|:----:|:---------------:|:-------:| | 0.0023 | 9.0 | 1000 | 0.3616 | 18.4644 | | b4b7e47062ed50aa50dd064791e3f82d |
apache-2.0 | ['speech', 'hf-asr-leaderboard'] | false | Data2Vec-Audio-Base-960h [Facebook's Data2Vec](https://ai.facebook.com/research/data2vec-a-general-framework-for-self-supervised-learning-in-speech-vision-and-language/) The base model pretrained and fine-tuned on 960 hours of Librispeech on 16kHz sampled speech audio. When using the model make sure that your speech input is also sampled at 16Khz. [Paper](https://arxiv.org/abs/2202.03555) Authors: Alexei Baevski, Wei-Ning Hsu, Qiantong Xu, Arun Babu, Jiatao Gu, Michael Auli **Abstract** While the general idea of self-supervised learning is identical across modalities, the actual algorithms and objectives differ widely because they were developed with a single modality in mind. To get us closer to general self-supervised learning, we present data2vec, a framework that uses the same learning method for either speech, NLP or computer vision. The core idea is to predict latent representations of the full input data based on a masked view of the input in a self-distillation setup using a standard Transformer architecture. Instead of predicting modality-specific targets such as words, visual tokens or units of human speech which are local in nature, data2vec predicts contextualized latent representations that contain information from the entire input. Experiments on the major benchmarks of speech recognition, image classification, and natural language understanding demonstrate a new state of the art or competitive performance to predominant approaches. The original model can be found under https://github.com/pytorch/fairseq/tree/main/examples/data2vec . | d4c0a31c8d945d0dac2b6051d946283d |
apache-2.0 | ['speech', 'hf-asr-leaderboard'] | false | Pre-Training method  For more information, please take a look at the [official paper](https://arxiv.org/abs/2202.03555). | e6a6fb1482ac311cd926553d17da45d3 |
apache-2.0 | ['speech', 'hf-asr-leaderboard'] | false | Usage To transcribe audio files the model can be used as a standalone acoustic model as follows: ```python from transformers import Wav2Vec2Processor, Data2VecForCTC from datasets import load_dataset import torch | 71b7f0105ed6a67077ca254012b634cf |
apache-2.0 | ['speech', 'hf-asr-leaderboard'] | false | Evaluation This code snippet shows how to evaluate **facebook/data2vec-audio-base-960h** on LibriSpeech's "clean" and "other" test data. ```python from transformers import Wav2Vec2Processor, Data2VecForCTC from datasets import load_dataset import torch from jiwer import wer | 51d6afaa366746d4c571061323f59b8a |
apache-2.0 | ['speech', 'hf-asr-leaderboard'] | false | load model and processor processor = Wav2Vec2Processor.from_pretrained("facebook/data2vec-audio-base-960h").to("cuda") model = Data2VecForCTC.from_pretrained("facebook/data2vec-audio-base-960h") librispeech_eval = load_dataset("librispeech_asr", "clean", split="test") def map_to_pred(batch): input_values = processor(batch["audio"]["array"], return_tensors="pt", padding="longest").input_values with torch.no_grad(): logits = model(input_values.to("cuda")).logits predicted_ids = torch.argmax(logits, dim=-1) transcription = processor.batch_decode(predicted_ids) batch["transcription"] = transcription return batch result = librispeech_eval.map(map_to_pred, batched=True, batch_size=1, remove_columns=["audio"]) print("WER:", wer(result["text"], result["transcription"])) ``` *Result (WER)*: | "clean" | "other" | |---|---| | 2.77 | 7.08 | | 73dbc65f88bf9ebcb9d1881fb977650a |
apache-2.0 | ['generated_from_trainer'] | false | distilbert-base-uncased-ner-invoiceSenderName_all_inv_20_12 This model is a fine-tuned version of [distilbert-base-uncased](https://huggingface.co/distilbert-base-uncased) on the None dataset. It achieves the following results on the evaluation set: - eval_loss: 0.0145 - eval_precision: 0.0 - eval_recall: 0.0 - eval_f1: 0.0 - eval_accuracy: 0.9957 - eval_runtime: 511.2392 - eval_samples_per_second: 42.113 - eval_steps_per_second: 2.633 - epoch: 4.0 - step: 30500 | 0da637d8fccb08a47f9d83bee72c6e43 |
apache-2.0 | ['generated_from_trainer'] | false | distilbert-imdb This model is a fine-tuned version of [distilbert-base-uncased](https://huggingface.co/distilbert-base-uncased) on the imdb dataset. It achieves the following results on the evaluation set: - Loss: 0.1819 - Accuracy: 0.9289 | c87ce5a72cf036331aea854d0ff5759e |
apache-2.0 | ['generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - train_batch_size: 32 - eval_batch_size: 32 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 1 | b86b69634e8b3bfb28a263a4112bb50f |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Accuracy | |:-------------:|:-----:|:----:|:---------------:|:--------:| | 0.2723 | 1.0 | 782 | 0.1819 | 0.9289 | | 32f0e4436c08825c87871c8c5631a05a |
apache-2.0 | ['exbert'] | false | BERT base model (uncased) Pretrained model on English language using a masked language modeling (MLM) objective. It was introduced in [this paper](https://arxiv.org/abs/1810.04805) and first released in [this repository](https://github.com/google-research/bert). This model is uncased: it does not make a difference between english and English. Disclaimer: The team releasing BERT did not write a model card for this model so this model card has been written by the Hugging Face team. | eff66885a9593c34f476dc8d749127fd |
apache-2.0 | ['exbert'] | false | Model description BERT is a transformers model pretrained on a large corpus of English data in a self-supervised fashion. This means it was pretrained on the raw texts only, with no humans labeling them in any way (which is why it can use lots of publicly available data) with an automatic process to generate inputs and labels from those texts. More precisely, it was pretrained with two objectives: - Masked language modeling (MLM): taking a sentence, the model randomly masks 15% of the words in the input then run the entire masked sentence through the model and has to predict the masked words. This is different from traditional recurrent neural networks (RNNs) that usually see the words one after the other, or from autoregressive models like GPT which internally masks the future tokens. It allows the model to learn a bidirectional representation of the sentence. - Next sentence prediction (NSP): the models concatenates two masked sentences as inputs during pretraining. Sometimes they correspond to sentences that were next to each other in the original text, sometimes not. The model then has to predict if the two sentences were following each other or not. This way, the model learns an inner representation of the English language that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled sentences, for instance, you can train a standard classifier using the features produced by the BERT model as inputs. | c1f74e67d6ef6448b70203d15db3adb2 |
apache-2.0 | ['exbert'] | false | Model variations BERT has originally been released in base and large variations, for cased and uncased input text. The uncased models also strips out an accent markers. Chinese and multilingual uncased and cased versions followed shortly after. Modified preprocessing with whole word masking has replaced subpiece masking in a following work, with the release of two models. Other 24 smaller models are released afterward. The detailed release history can be found on the [google-research/bert readme](https://github.com/google-research/bert/blob/master/README.md) on github. | Model | | 49bc883c79fe6f1bb239dc6b6b45a11a |
apache-2.0 | ['exbert'] | false | params | Language | |------------------------|--------------------------------|-------| | [`bert-base-uncased`](https://huggingface.co/bert-base-uncased) | 110M | English | | [`bert-large-uncased`](https://huggingface.co/bert-large-uncased) | 340M | English | sub | [`bert-base-cased`](https://huggingface.co/bert-base-cased) | 110M | English | | [`bert-large-cased`](https://huggingface.co/bert-large-cased) | 340M | English | | [`bert-base-chinese`](https://huggingface.co/bert-base-chinese) | 110M | Chinese | | [`bert-base-multilingual-cased`](https://huggingface.co/bert-base-multilingual-cased) | 110M | Multiple | | [`bert-large-uncased-whole-word-masking`](https://huggingface.co/bert-large-uncased-whole-word-masking) | 340M | English | | [`bert-large-cased-whole-word-masking`](https://huggingface.co/bert-large-cased-whole-word-masking) | 340M | English | | 085bf857ff1f8da8f35f40adffe34979 |
apache-2.0 | ['exbert'] | false | Intended uses & limitations You can use the raw model for either masked language modeling or next sentence prediction, but it's mostly intended to be fine-tuned on a downstream task. See the [model hub](https://huggingface.co/models?filter=bert) to look for fine-tuned versions of a task that interests you. Note that this model is primarily aimed at being fine-tuned on tasks that use the whole sentence (potentially masked) to make decisions, such as sequence classification, token classification or question answering. For tasks such as text generation you should look at model like GPT2. | 4d7f1df91811c674baaf8584872e8122 |
apache-2.0 | ['exbert'] | false | How to use You can use this model directly with a pipeline for masked language modeling: ```python >>> from transformers import pipeline >>> unmasker = pipeline('fill-mask', model='bert-base-uncased') >>> unmasker("Hello I'm a [MASK] model.") [{'sequence': "[CLS] hello i'm a fashion model. [SEP]", 'score': 0.1073106899857521, 'token': 4827, 'token_str': 'fashion'}, {'sequence': "[CLS] hello i'm a role model. [SEP]", 'score': 0.08774490654468536, 'token': 2535, 'token_str': 'role'}, {'sequence': "[CLS] hello i'm a new model. [SEP]", 'score': 0.05338378623127937, 'token': 2047, 'token_str': 'new'}, {'sequence': "[CLS] hello i'm a super model. [SEP]", 'score': 0.04667217284440994, 'token': 3565, 'token_str': 'super'}, {'sequence': "[CLS] hello i'm a fine model. [SEP]", 'score': 0.027095865458250046, 'token': 2986, 'token_str': 'fine'}] ``` Here is how to use this model to get the features of a given text in PyTorch: ```python from transformers import BertTokenizer, BertModel tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertModel.from_pretrained("bert-base-uncased") text = "Replace me by any text you'd like." encoded_input = tokenizer(text, return_tensors='pt') output = model(**encoded_input) ``` and in TensorFlow: ```python from transformers import BertTokenizer, TFBertModel tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = TFBertModel.from_pretrained("bert-base-uncased") text = "Replace me by any text you'd like." encoded_input = tokenizer(text, return_tensors='tf') output = model(encoded_input) ``` | 00cc61da1ba6647d9a6d99545c0861d0 |
apache-2.0 | ['exbert'] | false | Limitations and bias Even if the training data used for this model could be characterized as fairly neutral, this model can have biased predictions: ```python >>> from transformers import pipeline >>> unmasker = pipeline('fill-mask', model='bert-base-uncased') >>> unmasker("The man worked as a [MASK].") [{'sequence': '[CLS] the man worked as a carpenter. [SEP]', 'score': 0.09747550636529922, 'token': 10533, 'token_str': 'carpenter'}, {'sequence': '[CLS] the man worked as a waiter. [SEP]', 'score': 0.0523831807076931, 'token': 15610, 'token_str': 'waiter'}, {'sequence': '[CLS] the man worked as a barber. [SEP]', 'score': 0.04962705448269844, 'token': 13362, 'token_str': 'barber'}, {'sequence': '[CLS] the man worked as a mechanic. [SEP]', 'score': 0.03788609802722931, 'token': 15893, 'token_str': 'mechanic'}, {'sequence': '[CLS] the man worked as a salesman. [SEP]', 'score': 0.037680890411138535, 'token': 18968, 'token_str': 'salesman'}] >>> unmasker("The woman worked as a [MASK].") [{'sequence': '[CLS] the woman worked as a nurse. [SEP]', 'score': 0.21981462836265564, 'token': 6821, 'token_str': 'nurse'}, {'sequence': '[CLS] the woman worked as a waitress. [SEP]', 'score': 0.1597415804862976, 'token': 13877, 'token_str': 'waitress'}, {'sequence': '[CLS] the woman worked as a maid. [SEP]', 'score': 0.1154729500412941, 'token': 10850, 'token_str': 'maid'}, {'sequence': '[CLS] the woman worked as a prostitute. [SEP]', 'score': 0.037968918681144714, 'token': 19215, 'token_str': 'prostitute'}, {'sequence': '[CLS] the woman worked as a cook. [SEP]', 'score': 0.03042375110089779, 'token': 5660, 'token_str': 'cook'}] ``` This bias will also affect all fine-tuned versions of this model. | 177843f83860becfbba72e6783b9d369 |
apache-2.0 | ['exbert'] | false | Training data The BERT model was pretrained on [BookCorpus](https://yknzhu.wixsite.com/mbweb), a dataset consisting of 11,038 unpublished books and [English Wikipedia](https://en.wikipedia.org/wiki/English_Wikipedia) (excluding lists, tables and headers). | 7231b864ba9e4eff9f414d4bfc60a6f9 |
apache-2.0 | ['exbert'] | false | Preprocessing The texts are lowercased and tokenized using WordPiece and a vocabulary size of 30,000. The inputs of the model are then of the form: ``` [CLS] Sentence A [SEP] Sentence B [SEP] ``` With probability 0.5, sentence A and sentence B correspond to two consecutive sentences in the original corpus, and in the other cases, it's another random sentence in the corpus. Note that what is considered a sentence here is a consecutive span of text usually longer than a single sentence. The only constrain is that the result with the two "sentences" has a combined length of less than 512 tokens. The details of the masking procedure for each sentence are the following: - 15% of the tokens are masked. - In 80% of the cases, the masked tokens are replaced by `[MASK]`. - In 10% of the cases, the masked tokens are replaced by a random token (different) from the one they replace. - In the 10% remaining cases, the masked tokens are left as is. | 5d15b85bc1d020c70e1387b1866ebf19 |
apache-2.0 | ['exbert'] | false | Pretraining The model was trained on 4 cloud TPUs in Pod configuration (16 TPU chips total) for one million steps with a batch size of 256. The sequence length was limited to 128 tokens for 90% of the steps and 512 for the remaining 10%. The optimizer used is Adam with a learning rate of 1e-4, \\(\beta_{1} = 0.9\\) and \\(\beta_{2} = 0.999\\), a weight decay of 0.01, learning rate warmup for 10,000 steps and linear decay of the learning rate after. | 1e5b0c6c2e458e95155ba5031408d4ae |
apache-2.0 | ['exbert'] | false | Evaluation results When fine-tuned on downstream tasks, this model achieves the following results: Glue test results: | Task | MNLI-(m/mm) | QQP | QNLI | SST-2 | CoLA | STS-B | MRPC | RTE | Average | |:----:|:-----------:|:----:|:----:|:-----:|:----:|:-----:|:----:|:----:|:-------:| | | 84.6/83.4 | 71.2 | 90.5 | 93.5 | 52.1 | 85.8 | 88.9 | 66.4 | 79.6 | | 3dfae41373986c482b4586c2eb1e6ec0 |
apache-2.0 | ['exbert'] | false | BibTeX entry and citation info ```bibtex @article{DBLP:journals/corr/abs-1810-04805, author = {Jacob Devlin and Ming{-}Wei Chang and Kenton Lee and Kristina Toutanova}, title = {{BERT:} Pre-training of Deep Bidirectional Transformers for Language Understanding}, journal = {CoRR}, volume = {abs/1810.04805}, year = {2018}, url = {http://arxiv.org/abs/1810.04805}, archivePrefix = {arXiv}, eprint = {1810.04805}, timestamp = {Tue, 30 Oct 2018 20:39:56 +0100}, biburl = {https://dblp.org/rec/journals/corr/abs-1810-04805.bib}, bibsource = {dblp computer science bibliography, https://dblp.org} } ``` <a href="https://huggingface.co/exbert/?model=bert-base-uncased"> <img width="300px" src="https://cdn-media.huggingface.co/exbert/button.png"> </a> | 9f63fdf69b197b5251fdf05b931cb407 |
mit | ['generated_from_trainer'] | false | gpt2-finetuning-sentiment-model-3000-samples This model is a fine-tuned version of [gpt2](https://huggingface.co/gpt2) on the imdb dataset. It achieves the following results on the evaluation set: - Loss: 1.7442 - Accuracy: 0.6467 - F1: 0.6159 | cd79f06f567c5a29682e04f068c734ea |
cc-by-sa-4.0 | ['japanese', 'masked-lm'] | false | Model Description This is a RoBERTa model pre-trained on 青空文庫 texts with character tokenizer. You can fine-tune `roberta-small-japanese-aozora-char` for downstream tasks, such as [POS-tagging](https://huggingface.co/KoichiYasuoka/roberta-small-japanese-char-luw-upos), dependency-parsing, and so on. | 04e2a2f6b369d3d15f27509681eaf1b4 |
cc-by-sa-4.0 | ['japanese', 'masked-lm'] | false | How to Use ```py from transformers import AutoTokenizer,AutoModelForMaskedLM tokenizer=AutoTokenizer.from_pretrained("KoichiYasuoka/roberta-small-japanese-aozora-char") model=AutoModelForMaskedLM.from_pretrained("KoichiYasuoka/roberta-small-japanese-aozora-char") ``` | 1997e5815c5e8cdeb8384a21e4bc5225 |
apache-2.0 | ['translation'] | false | opus-mt-lua-fi * source languages: lua * target languages: fi * OPUS readme: [lua-fi](https://github.com/Helsinki-NLP/OPUS-MT-train/blob/master/models/lua-fi/README.md) * dataset: opus * model: transformer-align * pre-processing: normalization + SentencePiece * download original weights: [opus-2020-01-09.zip](https://object.pouta.csc.fi/OPUS-MT-models/lua-fi/opus-2020-01-09.zip) * test set translations: [opus-2020-01-09.test.txt](https://object.pouta.csc.fi/OPUS-MT-models/lua-fi/opus-2020-01-09.test.txt) * test set scores: [opus-2020-01-09.eval.txt](https://object.pouta.csc.fi/OPUS-MT-models/lua-fi/opus-2020-01-09.eval.txt) | afafb1e10dce2f02bd9d592b1088f28c |
apache-2.0 | ['generated_from_trainer'] | false | t5-small-finetuned-xsum This model is a fine-tuned version of [t5-small](https://huggingface.co/t5-small) on the eli5 dataset. It achieves the following results on the evaluation set: - Loss: 3.6746 - Rouge1: 13.2962 - Rouge2: 2.0081 - Rougel: 10.6529 - Rougelsum: 12.049 - Gen Len: 18.9985 | 4a758fb1dca260ea52676899859f3c54 |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Rouge1 | Rouge2 | Rougel | Rougelsum | Gen Len | |:-------------:|:-----:|:-----:|:---------------:|:-------:|:------:|:-------:|:---------:|:-------:| | 3.8901 | 1.0 | 17040 | 3.6746 | 13.2962 | 2.0081 | 10.6529 | 12.049 | 18.9985 | | 83a1236c4d2a096ecd26c154ebb8367e |
mit | ['generated_from_keras_callback'] | false | Training hyperparameters The following hyperparameters were used during training: - optimizer: {'name': 'AdamWeightDecay', 'learning_rate': {'class_name': 'WarmUp', 'config': {'initial_learning_rate': 2e-05, 'decay_schedule_fn': {'class_name': 'PolynomialDecay', 'config': {'initial_learning_rate': 2e-05, 'decay_steps': 4400, 'end_learning_rate': 0.0, 'power': 1.0, 'cycle': False, 'name': None}, '__passive_serialization__': True}, 'warmup_steps': 1000, 'power': 1.0, 'name': None}}, 'decay': 0.0, 'beta_1': 0.9, 'beta_2': 0.999, 'epsilon': 1e-08, 'amsgrad': False, 'weight_decay_rate': 0.01} - training_precision: mixed_float16 | 89dbd2f4c274391571ea49007988748b |
mit | ['generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 3e-05 - train_batch_size: 12 - eval_batch_size: 8 - seed: 4 - distributed_type: multi-GPU - num_devices: 2 - total_train_batch_size: 24 - total_eval_batch_size: 16 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 2.0 | e3db54162d8fb8fef58fb7410e672d9e |
gpl-3.0 | ['pytorch', 'token-classification', 'bert', 'zh'] | false | Training Datasets The copyright of the datasets belongs to the Institute of Linguistics, Academia Sinica. * [中央研究院上古漢語標記語料庫](http://lingcorpus.iis.sinica.edu.tw/cgi-bin/kiwi/akiwi/kiwi.sh) * [中央研究院中古漢語語料庫](http://lingcorpus.iis.sinica.edu.tw/cgi-bin/kiwi/dkiwi/kiwi.sh) * [中央研究院近代漢語語料庫](http://lingcorpus.iis.sinica.edu.tw/cgi-bin/kiwi/pkiwi/kiwi.sh) * [中央研究院現代漢語語料庫](http://asbc.iis.sinica.edu.tw) | 3de493e14013a3905d249f64ee515412 |
apache-2.0 | ['generated_from_trainer'] | false | distilbert-base-uncased-finetuned-cola This model is a fine-tuned version of [distilbert-base-uncased](https://huggingface.co/distilbert-base-uncased) on the glue dataset. It achieves the following results on the evaluation set: - Loss: 0.8366 - Matthews Correlation: 0.5472 | 3009151c6a7bbebf95056e378f7f7fc4 |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Matthews Correlation | |:-------------:|:-----:|:----:|:---------------:|:--------------------:| | 0.5224 | 1.0 | 535 | 0.5432 | 0.4243 | | 0.3447 | 2.0 | 1070 | 0.4968 | 0.5187 | | 0.2347 | 3.0 | 1605 | 0.6540 | 0.5280 | | 0.1747 | 4.0 | 2140 | 0.7547 | 0.5367 | | 0.1255 | 5.0 | 2675 | 0.8366 | 0.5472 | | 76258a2255e7a80c1be94bad2ab2c255 |
mit | ['generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - train_batch_size: 1 - eval_batch_size: 1 - seed: 42 - gradient_accumulation_steps: 16 - total_train_batch_size: 16 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - lr_scheduler_warmup_steps: 500 - num_epochs: 1 | 5506556e42995386ff8654f7c5f9d212 |
apache-2.0 | ['generated_from_keras_callback'] | false | raisvaza/distilbert-base-uncased-finetuned-ner This model is a fine-tuned version of [distilbert-base-uncased](https://huggingface.co/distilbert-base-uncased) on an unknown dataset. It achieves the following results on the evaluation set: - Train Loss: 0.0352 - Validation Loss: 0.0607 - Train Precision: 0.9246 - Train Recall: 0.9330 - Train F1: 0.9288 - Train Accuracy: 0.9832 - Epoch: 2 | 72a0d17b28cc4da1254df499757d8a93 |
apache-2.0 | ['generated_from_keras_callback'] | false | Training hyperparameters The following hyperparameters were used during training: - optimizer: {'name': 'AdamWeightDecay', 'learning_rate': {'class_name': 'PolynomialDecay', 'config': {'initial_learning_rate': 2e-05, 'decay_steps': 2631, 'end_learning_rate': 0.0, 'power': 1.0, 'cycle': False, 'name': None}}, 'decay': 0.0, 'beta_1': 0.9, 'beta_2': 0.999, 'epsilon': 1e-08, 'amsgrad': False, 'weight_decay_rate': 0.01} - training_precision: float32 | 675d3ce612975f47b69cb2469683be48 |
apache-2.0 | ['generated_from_keras_callback'] | false | Training results | Train Loss | Validation Loss | Train Precision | Train Recall | Train F1 | Train Accuracy | Epoch | |:----------:|:---------------:|:---------------:|:------------:|:--------:|:--------------:|:-----:| | 0.1955 | 0.0720 | 0.8998 | 0.9157 | 0.9077 | 0.9792 | 0 | | 0.0557 | 0.0620 | 0.9200 | 0.9271 | 0.9235 | 0.9822 | 1 | | 0.0352 | 0.0607 | 0.9246 | 0.9330 | 0.9288 | 0.9832 | 2 | | be4715ff90d51b834d21dfe8071443da |
gpl-3.0 | ['object-detection', 'computer-vision', 'yolov8', 'yolov5'] | false | Yolov8 Inference ```python from ultralytics import YOLO model = YOLO('kadirnar/yolov8l-v8.0') model.conf = conf_threshold model.iou = iou_threshold prediction = model.predict(image, imgsz=image_size, show=False, save=False) ``` | b95e9ca6b691476fa7076ffb5fdb7a84 |
apache-2.0 | ['summarization', 'generated_from_trainer'] | false | mt5-small-finetuned-amazon-en-es This model is a fine-tuned version of [google/mt5-small](https://huggingface.co/google/mt5-small) on the None dataset. It achieves the following results on the evaluation set: - Loss: 3.0393 - Rouge1: 17.2936 - Rouge2: 8.0678 - Rougel: 16.8129 - Rougelsum: 16.9991 | 0714b4eae294dc9020a3f9f9d2dcbb6d |
apache-2.0 | ['summarization', 'generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Rouge1 | Rouge2 | Rougel | Rougelsum | |:-------------:|:-----:|:----:|:---------------:|:-------:|:------:|:-------:|:---------:| | 6.6665 | 1.0 | 1209 | 3.2917 | 13.912 | 5.595 | 13.2984 | 13.4171 | | 3.8961 | 2.0 | 2418 | 3.1711 | 16.2845 | 8.6033 | 15.5509 | 15.7383 | | 3.5801 | 3.0 | 3627 | 3.0917 | 17.316 | 8.122 | 16.697 | 16.773 | | 3.4258 | 4.0 | 4836 | 3.0583 | 16.1347 | 7.7829 | 15.6475 | 15.7804 | | 3.3154 | 5.0 | 6045 | 3.0573 | 17.5918 | 8.7349 | 17.0537 | 17.2216 | | 3.2438 | 6.0 | 7254 | 3.0479 | 17.2294 | 8.0383 | 16.8141 | 16.9858 | | 3.2024 | 7.0 | 8463 | 3.0377 | 17.2918 | 8.139 | 16.8178 | 16.9671 | | 3.1745 | 8.0 | 9672 | 3.0393 | 17.2936 | 8.0678 | 16.8129 | 16.9991 | | c7778317762896486d815f4ac833cb35 |
mit | ['vision', 'video-classification'] | false | X-CLIP (base-sized model) X-CLIP model (base-sized, patch resolution of 16) trained in a few-shot fashion (K=8) on [HMDB-51](https://serre-lab.clps.brown.edu/resource/hmdb-a-large-human-motion-database/). It was introduced in the paper [Expanding Language-Image Pretrained Models for General Video Recognition](https://arxiv.org/abs/2208.02816) by Ni et al. and first released in [this repository](https://github.com/microsoft/VideoX/tree/master/X-CLIP). This model was trained using 32 frames per video, at a resolution of 224x224. Disclaimer: The team releasing X-CLIP did not write a model card for this model so this model card has been written by the Hugging Face team. | ecee394b1f25592a4cba2ba76633f19b |
mit | [] | false | turtlepics on Stable Diffusion This is the `<henry-leonardi>` concept taught to Stable Diffusion via Textual Inversion. You can load this concept into the [Stable Conceptualizer](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/stable_conceptualizer_inference.ipynb) notebook. You can also train your own concepts and load them into the concept libraries using [this notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/sd_textual_inversion_training.ipynb). Here is the new concept you will be able to use as an `object`:     | 9b8d3382d13ce09ca8307a36c19baa25 |
apache-2.0 | ['generated_from_trainer'] | false | distilgpt2-finetuned-AT This model is a fine-tuned version of [distilgpt2](https://huggingface.co/distilgpt2) on the None dataset. It achieves the following results on the evaluation set: - Loss: 3.2450 | 00d97f2322311e82c7654f73c72bd5c4 |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | |:-------------:|:-----:|:----:|:---------------:| | No log | 1.0 | 279 | 3.3451 | | 3.4534 | 2.0 | 558 | 3.2941 | | 3.4534 | 3.0 | 837 | 3.2740 | | 3.2435 | 4.0 | 1116 | 3.2617 | | 3.2435 | 5.0 | 1395 | 3.2556 | | 3.1729 | 6.0 | 1674 | 3.2490 | | 3.1729 | 7.0 | 1953 | 3.2475 | | 3.1262 | 8.0 | 2232 | 3.2467 | | 3.0972 | 9.0 | 2511 | 3.2448 | | 3.0972 | 10.0 | 2790 | 3.2450 | | 9c5a4c2f9ac0c92ce2134f0af923484f |
apache-2.0 | ['generated_from_trainer'] | false | bert-base-goemotions This model is a fine-tuned version of [bert-base-uncased](https://huggingface.co/bert-base-uncased) on the go_emotions dataset. It achieves the following results on the evaluation set: - Loss: 0.1539 - F1: 0.5727 - Roc Auc: 0.7796 - Accuracy: 0.4375 | 0a7171598bf59cec88d249be038670b1 |
apache-2.0 | ['generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - train_batch_size: 16 - eval_batch_size: 16 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 10 | 75a3e1299fe6635d172bfdb78df019c3 |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | F1 | Roc Auc | Accuracy | |:-------------:|:-----:|:-----:|:---------------:|:------:|:-------:|:--------:| | 0.0833 | 1.0 | 2714 | 0.0876 | 0.5453 | 0.7189 | 0.4243 | | 0.0719 | 2.0 | 5428 | 0.0867 | 0.5586 | 0.7322 | 0.4399 | | 0.0575 | 3.0 | 8142 | 0.0943 | 0.5736 | 0.7523 | 0.4665 | | 0.0411 | 4.0 | 10856 | 0.1064 | 0.5655 | 0.7580 | 0.4574 | | 0.0301 | 5.0 | 13570 | 0.1167 | 0.5622 | 0.7591 | 0.4517 | | 0.0217 | 6.0 | 16284 | 0.1279 | 0.5579 | 0.7648 | 0.4375 | | 0.015 | 7.0 | 18998 | 0.1367 | 0.5663 | 0.7759 | 0.4333 | | 0.0102 | 8.0 | 21712 | 0.1445 | 0.5695 | 0.7793 | 0.4322 | | 0.0077 | 9.0 | 24426 | 0.1491 | 0.5725 | 0.7795 | 0.4366 | | 0.0057 | 10.0 | 27140 | 0.1539 | 0.5727 | 0.7796 | 0.4375 | | 295964d163c8510426253869df4f1433 |
apache-2.0 | ['generated_from_trainer'] | false | distilbert-base-uncased-finetuned-cola This model is a fine-tuned version of [distilbert-base-uncased](https://huggingface.co/distilbert-base-uncased) on the glue dataset. It achieves the following results on the evaluation set: - Loss: 0.8366 - Matthews Correlation: 0.5602 | d3a206169a7175029b800a00ec90618c |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Matthews Correlation | |:-------------:|:-----:|:----:|:---------------:|:--------------------:| | 0.5257 | 1.0 | 535 | 0.5475 | 0.4039 | | 0.3482 | 2.0 | 1070 | 0.5140 | 0.5004 | | 0.2408 | 3.0 | 1605 | 0.6472 | 0.5264 | | 0.1765 | 4.0 | 2140 | 0.7456 | 0.5403 | | 0.1314 | 5.0 | 2675 | 0.8366 | 0.5602 | | 8a4893478d123b6c68465d812d157c3c |
apache-2.0 | ['translation'] | false | opus-mt-de-fj * source languages: de * target languages: fj * OPUS readme: [de-fj](https://github.com/Helsinki-NLP/OPUS-MT-train/blob/master/models/de-fj/README.md) * dataset: opus * model: transformer-align * pre-processing: normalization + SentencePiece * download original weights: [opus-2020-01-20.zip](https://object.pouta.csc.fi/OPUS-MT-models/de-fj/opus-2020-01-20.zip) * test set translations: [opus-2020-01-20.test.txt](https://object.pouta.csc.fi/OPUS-MT-models/de-fj/opus-2020-01-20.test.txt) * test set scores: [opus-2020-01-20.eval.txt](https://object.pouta.csc.fi/OPUS-MT-models/de-fj/opus-2020-01-20.eval.txt) | 843d6de74eaab3d3e4ddac7dd5fcf2d5 |
apache-2.0 | ['generated_from_trainer'] | false | t5-end2end-questions-generation This model is a fine-tuned version of [t5-base](https://huggingface.co/t5-base) on the squad_modified_for_t5_qg dataset. It achieves the following results on the evaluation set: - Loss: 1.8015 | c6981e4df2bda278641a11bb4f18dc6b |
apache-2.0 | ['generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 0.0001 - train_batch_size: 4 - eval_batch_size: 4 - seed: 42 - gradient_accumulation_steps: 16 - total_train_batch_size: 64 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 1 | 8dc5cee7602a45cd517b5bf6136c067f |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | |:-------------:|:-----:|:----:|:---------------:| | 2.609 | 0.34 | 100 | 1.9542 | | 2.0336 | 0.68 | 200 | 1.8015 | | b85ebb0e3ee4dca41b038f3d2ef3fa72 |
apache-2.0 | ['generated_from_trainer'] | false | distilr2-lr1e05-wd0.1-bs64 This model is a fine-tuned version of [distilroberta-base](https://huggingface.co/distilroberta-base) on the None dataset. It achieves the following results on the evaluation set: - Loss: 0.2723 - Rmse: 0.5219 - Mse: 0.2723 - Mae: 0.4098 | 868ab5a21670812b33bb4ab7b30f8b17 |
apache-2.0 | ['generated_from_trainer'] | false | Training hyperparameters The following hyperparameters were used during training: - learning_rate: 1e-05 - train_batch_size: 512 - eval_batch_size: 512 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 10 | a713d716fa041209c4522e27adc10568 |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Rmse | Mse | Mae | |:-------------:|:-----:|:----:|:---------------:|:------:|:------:|:------:| | 0.2779 | 1.0 | 312 | 0.2756 | 0.5250 | 0.2756 | 0.4246 | | 0.2747 | 2.0 | 624 | 0.2734 | 0.5229 | 0.2734 | 0.4091 | | 0.2732 | 3.0 | 936 | 0.2726 | 0.5221 | 0.2726 | 0.4155 | | 0.2714 | 4.0 | 1248 | 0.2723 | 0.5219 | 0.2723 | 0.4098 | | d3d1d596b1984b7ae04b4515270ae3ce |
apache-2.0 | ['generated_from_trainer'] | false | flan-t5-gov-report-sum This model is a fine-tuned version of [google/flan-t5-base](https://huggingface.co/google/flan-t5-base) on the govreport-summarization dataset. It achieves the following results on the evaluation set: - Loss: 2.2385 - Rouge1: 5.8729 - Rouge2: 3.0763 - Rougel: 5.1016 - Rougelsum: 5.646 - Gen Len: 19.0 | c2d6bfac7f171ec1eea616ece14ce17e |
apache-2.0 | ['generated_from_trainer'] | false | Training results | Training Loss | Epoch | Step | Validation Loss | Rouge1 | Rouge2 | Rougel | Rougelsum | Gen Len | |:-------------:|:-----:|:-----:|:---------------:|:------:|:------:|:------:|:---------:|:-------:| | 2.5801 | 1.0 | 2190 | 2.3211 | 5.6226 | 2.9142 | 4.9535 | 5.417 | 19.0 | | 2.5125 | 2.0 | 4380 | 2.2748 | 5.7982 | 3.0365 | 5.0726 | 5.5837 | 19.0 | | 2.453 | 3.0 | 6570 | 2.2545 | 5.8744 | 3.0997 | 5.1196 | 5.6524 | 19.0 | | 2.436 | 4.0 | 8760 | 2.2430 | 5.8669 | 3.0525 | 5.0849 | 5.631 | 19.0 | | 2.4144 | 5.0 | 10950 | 2.2385 | 5.8729 | 3.0763 | 5.1016 | 5.646 | 19.0 | | dd3b2f6eeb7b96839177e8a7231bbf52 |
mit | ['generated_from_trainer'] | false | xlm-roberta-base-finetuned-panx-all This model is a fine-tuned version of [xlm-roberta-base](https://huggingface.co/xlm-roberta-base) on the None dataset. It achieves the following results on the evaluation set: - Loss: 0.1757 - F1: 0.8513 | 72f91017376931d2c19b2180fb3024ec |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.