Datasets:

davanstrien

/

model_cards_with_readmes

like 1

Qalam/Lei

Qalam

text-to-image

apache-2.0

[]

<p align="center"> <br> <img src="./docs/source/en/imgs/diffusers_library.jpg" width="400"/> <br> <p> <p align="center"> <a href="https://github.com/huggingface/diffusers/blob/main/LICENSE"> <img alt="GitHub" src="https://img.shields.io/github/license/huggingface/datasets.svg?color=blue"> </a> <a href="https://github.com/huggingface/diffusers/releases"> <img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/diffusers.svg"> </a> <a href="CODE_OF_CONDUCT.md"> <img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg"> </a> </p> 🤗 Diffusers provides pretrained diffusion models across multiple modalities, such as vision and audio, and serves as a modular toolbox for inference and training of diffusion models. More precisely, 🤗 Diffusers offers: - State-of-the-art diffusion pipelines that can be run in inference with just a couple of lines of code (see [src/diffusers/pipelines](https://github.com/huggingface/diffusers/tree/main/src/diffusers/pipelines)). Check [this overview](https://github.com/huggingface/diffusers/tree/main/src/diffusers/pipelines/README.md#pipelines-summary) to see all supported pipelines and their corresponding official papers. - Various noise schedulers that can be used interchangeably for the preferred speed vs. quality trade-off in inference (see [src/diffusers/schedulers](https://github.com/huggingface/diffusers/tree/main/src/diffusers/schedulers)). - Multiple types of models, such as UNet, can be used as building blocks in an end-to-end diffusion system (see [src/diffusers/models](https://github.com/huggingface/diffusers/tree/main/src/diffusers/models)). - Training examples to show how to train the most popular diffusion model tasks (see [examples](https://github.com/huggingface/diffusers/tree/main/examples), *e.g.* [unconditional-image-generation](https://github.com/huggingface/diffusers/tree/main/examples/unconditional_image_generation)). ## Installation ### For PyTorch **With `pip`** (official package) ```bash pip install --upgrade diffusers[torch] ``` **With `conda`** (maintained by the community) ```sh conda install -c conda-forge diffusers ``` ### For Flax **With `pip`** ```bash pip install --upgrade diffusers[flax] ``` **Apple Silicon (M1/M2) support** Please, refer to [the documentation](https://huggingface.co/docs/diffusers/optimization/mps). ## Contributing We ❤️ contributions from the open-source community! If you want to contribute to this library, please check out our [Contribution guide](https://github.com/huggingface/diffusers/blob/main/CONTRIBUTING.md). You can look out for [issues](https://github.com/huggingface/diffusers/issues) you'd like to tackle to contribute to the library. - See [Good first issues](https://github.com/huggingface/diffusers/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22) for general opportunities to contribute - See [New model/pipeline](https://github.com/huggingface/diffusers/issues?q=is%3Aopen+is%3Aissue+label%3A%22New+pipeline%2Fmodel%22) to contribute exciting new diffusion models / diffusion pipelines - See [New scheduler](https://github.com/huggingface/diffusers/issues?q=is%3Aopen+is%3Aissue+label%3A%22New+scheduler%22) Also, say 👋 in our public Discord channel <a href="https://discord.gg/G7tWnz98XR"><img alt="Join us on Discord" src="https://img.shields.io/discord/823813159592001537?color=5865F2&logo=discord&logoColor=white"></a>. We discuss the hottest trends about diffusion models, help each other with contributions, personal projects or just hang out ☕. ## Quickstart In order to get started, we recommend taking a look at two notebooks: - The [Getting started with Diffusers](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/diffusers_intro.ipynb) [](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/diffusers_intro.ipynb) notebook, which showcases an end-to-end example of usage for diffusion models, schedulers and pipelines. Take a look at this notebook to learn how to use the pipeline abstraction, which takes care of everything (model, scheduler, noise handling) for you, and also to understand each independent building block in the library. - The [Training a diffusers model](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/training_example.ipynb) [](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/training_example.ipynb) notebook summarizes diffusion models training methods. This notebook takes a step-by-step approach to training your diffusion models on an image dataset, with explanatory graphics. ## Stable Diffusion is fully compatible with `diffusers`! Stable Diffusion is a text-to-image latent diffusion model created by the researchers and engineers from [CompVis](https://github.com/CompVis), [Stability AI](https://stability.ai/), [LAION](https://laion.ai/) and [RunwayML](https://runwayml.com/). It's trained on 512x512 images from a subset of the [LAION-5B](https://laion.ai/blog/laion-5b/) database. This model uses a frozen CLIP ViT-L/14 text encoder to condition the model on text prompts. With its 860M UNet and 123M text encoder, the model is relatively lightweight and runs on a GPU with at least 4GB VRAM. See the [model card](https://huggingface.co/CompVis/stable-diffusion) for more information. ### Text-to-Image generation with Stable Diffusion First let's install ```bash pip install --upgrade diffusers transformers accelerate ``` We recommend using the model in [half-precision (`fp16`)](https://pytorch.org/blog/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision/) as it gives almost always the same results as full precision while being roughly twice as fast and requiring half the amount of GPU RAM. ```python import torch from diffusers import StableDiffusionPipeline pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16) pipe = pipe.to("cuda") prompt = "a photo of an astronaut riding a horse on mars" image = pipe(prompt).images[0] ``` #### Running the model locally You can also simply download the model folder and pass the path to the local folder to the `StableDiffusionPipeline`. ``` git lfs install git clone https://huggingface.co/runwayml/stable-diffusion-v1-5 ``` Assuming the folder is stored locally under `./stable-diffusion-v1-5`, you can run stable diffusion as follows: ```python pipe = StableDiffusionPipeline.from_pretrained("./stable-diffusion-v1-5") pipe = pipe.to("cuda") prompt = "a photo of an astronaut riding a horse on mars" image = pipe(prompt).images[0] ``` If you are limited by GPU memory, you might want to consider chunking the attention computation in addition to using `fp16`. The following snippet should result in less than 4GB VRAM. ```python pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16) pipe = pipe.to("cuda") prompt = "a photo of an astronaut riding a horse on mars" pipe.enable_attention_slicing() image = pipe(prompt).images[0] ``` If you wish to use a different scheduler (e.g.: DDIM, LMS, PNDM/PLMS), you can instantiate it before the pipeline and pass it to `from_pretrained`. ```python from diffusers import LMSDiscreteScheduler pipe.scheduler = LMSDiscreteScheduler.from_config(pipe.scheduler.config) prompt = "a photo of an astronaut riding a horse on mars" image = pipe(prompt).images[0] image.save("astronaut_rides_horse.png") ``` If you want to run Stable Diffusion on CPU or you want to have maximum precision on GPU, please run the model in the default *full-precision* setting: ```python from diffusers import StableDiffusionPipeline pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5") # disable the following line if you run on CPU 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") ``` ### JAX/Flax Diffusers offers a JAX / Flax implementation of Stable Diffusion for very fast inference. JAX shines specially on TPU hardware because each TPU server has 8 accelerators working in parallel, but it runs great on GPUs too. Running the pipeline with the 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( "runwayml/stable-diffusion-v1-5", 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) # shard inputs and rng params = replicate(params) prng_seed = jax.random.split(prng_seed, jax.device_count()) 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( "runwayml/stable-diffusion-v1-5", 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) # shard inputs and rng params = replicate(params) prng_seed = jax.random.split(prng_seed, jax.device_count()) 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:]))) ``` Diffusers also has a Image-to-Image generation pipeline with Flax/Jax ```python import jax import numpy as np import jax.numpy as jnp from flax.jax_utils import replicate from flax.training.common_utils import shard import requests from io import BytesIO from PIL import Image from diffusers import FlaxStableDiffusionImg2ImgPipeline def create_key(seed=0): return jax.random.PRNGKey(seed) rng = create_key(0) url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg" response = requests.get(url) init_img = Image.open(BytesIO(response.content)).convert("RGB") init_img = init_img.resize((768, 512)) prompts = "A fantasy landscape, trending on artstation" pipeline, params = FlaxStableDiffusionImg2ImgPipeline.from_pretrained( "CompVis/stable-diffusion-v1-4", revision="flax", dtype=jnp.bfloat16, ) num_samples = jax.device_count() rng = jax.random.split(rng, jax.device_count()) prompt_ids, processed_image = pipeline.prepare_inputs(prompt=[prompts]*num_samples, image = [init_img]*num_samples) p_params = replicate(params) prompt_ids = shard(prompt_ids) processed_image = shard(processed_image) output = pipeline( prompt_ids=prompt_ids, image=processed_image, params=p_params, prng_seed=rng, strength=0.75, num_inference_steps=50, jit=True, height=512, width=768).images output_images = pipeline.numpy_to_pil(np.asarray(output.reshape((num_samples,) + output.shape[-3:]))) ``` Diffusers also has a Text-guided inpainting pipeline with Flax/Jax ```python import jax import numpy as np from flax.jax_utils import replicate from flax.training.common_utils import shard import PIL import requests from io import BytesIO from diffusers import FlaxStableDiffusionInpaintPipeline def download_image(url): response = requests.get(url) return PIL.Image.open(BytesIO(response.content)).convert("RGB") img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png" mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png" init_image = download_image(img_url).resize((512, 512)) mask_image = download_image(mask_url).resize((512, 512)) pipeline, params = FlaxStableDiffusionInpaintPipeline.from_pretrained("xvjiarui/stable-diffusion-2-inpainting") prompt = "Face of a yellow cat, high resolution, sitting on a park bench" prng_seed = jax.random.PRNGKey(0) num_inference_steps = 50 num_samples = jax.device_count() prompt = num_samples * [prompt] init_image = num_samples * [init_image] mask_image = num_samples * [mask_image] prompt_ids, processed_masked_images, processed_masks = pipeline.prepare_inputs(prompt, init_image, mask_image) # shard inputs and rng params = replicate(params) prng_seed = jax.random.split(prng_seed, jax.device_count()) prompt_ids = shard(prompt_ids) processed_masked_images = shard(processed_masked_images) processed_masks = shard(processed_masks) images = pipeline(prompt_ids, processed_masks, processed_masked_images, params, prng_seed, num_inference_steps, jit=True).images images = pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:]))) ``` ### Image-to-Image text-guided generation with Stable Diffusion The `StableDiffusionImg2ImgPipeline` lets you pass a text prompt and an initial image to condition the generation of new images. ```python import requests import torch from PIL import Image from io import BytesIO from diffusers import StableDiffusionImg2ImgPipeline # load the pipeline device = "cuda" model_id_or_path = "runwayml/stable-diffusion-v1-5" pipe = StableDiffusionImg2ImgPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16) # or download via git clone https://huggingface.co/runwayml/stable-diffusion-v1-5 # and pass `model_id_or_path="./stable-diffusion-v1-5"`. pipe = pipe.to(device) # let's download an initial image url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg" response = requests.get(url) init_image = Image.open(BytesIO(response.content)).convert("RGB") init_image = init_image.resize((768, 512)) prompt = "A fantasy landscape, trending on artstation" images = pipe(prompt=prompt, image=init_image, strength=0.75, guidance_scale=7.5).images images[0].save("fantasy_landscape.png") ``` You can also run this example on colab [](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/image_2_image_using_diffusers.ipynb) ### In-painting using Stable Diffusion The `StableDiffusionInpaintPipeline` lets you edit specific parts of an image by providing a mask and a text prompt. ```python import PIL import requests import torch from io import BytesIO from diffusers import StableDiffusionInpaintPipeline def download_image(url): response = requests.get(url) return PIL.Image.open(BytesIO(response.content)).convert("RGB") img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png" mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png" init_image = download_image(img_url).resize((512, 512)) mask_image = download_image(mask_url).resize((512, 512)) pipe = StableDiffusionInpaintPipeline.from_pretrained("runwayml/stable-diffusion-inpainting", torch_dtype=torch.float16) pipe = pipe.to("cuda") prompt = "Face of a yellow cat, high resolution, sitting on a park bench" image = pipe(prompt=prompt, image=init_image, mask_image=mask_image).images[0] ``` ### Tweak prompts reusing seeds and latents You can generate your own latents to reproduce results, or tweak your prompt on a specific result you liked. Please have a look at [Reusing seeds for deterministic generation](https://huggingface.co/docs/diffusers/main/en/using-diffusers/reusing_seeds). ## Fine-Tuning Stable Diffusion Fine-tuning techniques make it possible to adapt Stable Diffusion to your own dataset, or add new subjects to it. These are some of the techniques supported in `diffusers`: Textual Inversion is a technique for capturing novel concepts from a small number of example images in a way that can later be used to control text-to-image pipelines. It does so by learning new 'words' in the embedding space of the pipeline's text encoder. These special words can then be used within text prompts to achieve very fine-grained control of the resulting images. - Textual Inversion. Capture novel concepts from a small set of sample images, and associate them with new "words" in the embedding space of the text encoder. Please, refer to [our training examples](https://github.com/huggingface/diffusers/tree/main/examples/textual_inversion) or [documentation](https://huggingface.co/docs/diffusers/training/text_inversion) to try for yourself. - Dreambooth. Another technique to capture new concepts in Stable Diffusion. This method fine-tunes the UNet (and, optionally, also the text encoder) of the pipeline to achieve impressive results. Please, refer to [our training example](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth) and [training report](https://huggingface.co/blog/dreambooth) for additional details and training recommendations. - Full Stable Diffusion fine-tuning. If you have a more sizable dataset with a specific look or style, you can fine-tune Stable Diffusion so that it outputs images following those examples. This was the approach taken to create [a Pokémon Stable Diffusion model](https://huggingface.co/justinpinkney/pokemon-stable-diffusion) (by Justing Pinkney / Lambda Labs), [a Japanese specific version of Stable Diffusion](https://huggingface.co/spaces/rinna/japanese-stable-diffusion) (by [Rinna Co.](https://github.com/rinnakk/japanese-stable-diffusion/) and others. You can start at [our text-to-image fine-tuning example](https://github.com/huggingface/diffusers/tree/main/examples/text_to_image) and go from there. ## Stable Diffusion Community Pipelines The release of Stable Diffusion as an open source model has fostered a lot of interesting ideas and experimentation. Our [Community Examples folder](https://github.com/huggingface/diffusers/tree/main/examples/community) contains many ideas worth exploring, like interpolating to create animated videos, using CLIP Guidance for additional prompt fidelity, term weighting, and much more! [Take a look](https://huggingface.co/docs/diffusers/using-diffusers/custom_pipeline_overview) and [contribute your own](https://huggingface.co/docs/diffusers/using-diffusers/contribute_pipeline). ## Other Examples There are many ways to try running Diffusers! Here we outline code-focused tools (primarily using `DiffusionPipeline`s and Google Colab) and interactive web-tools. ### Running Code If you want to run the code yourself 💻, you can try out: - [Text-to-Image Latent Diffusion](https://huggingface.co/CompVis/ldm-text2im-large-256) ```python # !pip install diffusers["torch"] transformers from diffusers import DiffusionPipeline device = "cuda" model_id = "CompVis/ldm-text2im-large-256" # load model and scheduler ldm = DiffusionPipeline.from_pretrained(model_id) ldm = ldm.to(device) # run pipeline in inference (sample random noise and denoise) prompt = "A painting of a squirrel eating a burger" image = ldm([prompt], num_inference_steps=50, eta=0.3, guidance_scale=6).images[0] # save image image.save("squirrel.png") ``` - [Unconditional Diffusion with discrete scheduler](https://huggingface.co/google/ddpm-celebahq-256) ```python # !pip install diffusers["torch"] from diffusers import DDPMPipeline, DDIMPipeline, PNDMPipeline model_id = "google/ddpm-celebahq-256" device = "cuda" # load model and scheduler ddpm = DDPMPipeline.from_pretrained(model_id) # you can replace DDPMPipeline with DDIMPipeline or PNDMPipeline for faster inference ddpm.to(device) # run pipeline in inference (sample random noise and denoise) image = ddpm().images[0] # save image image.save("ddpm_generated_image.png") ``` - [Unconditional Latent Diffusion](https://huggingface.co/CompVis/ldm-celebahq-256) - [Unconditional Diffusion with continuous scheduler](https://huggingface.co/google/ncsnpp-ffhq-1024) **Other Image Notebooks**: * [image-to-image generation with Stable Diffusion](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/image_2_image_using_diffusers.ipynb) , * [tweak images via repeated Stable Diffusion seeds](https://colab.research.google.com/github/pcuenca/diffusers-examples/blob/main/notebooks/stable-diffusion-seeds.ipynb) , **Diffusers for Other Modalities**: * [Molecule conformation generation](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/geodiff_molecule_conformation.ipynb) , * [Model-based reinforcement learning](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/reinforcement_learning_with_diffusers.ipynb) , ### Web Demos If you just want to play around with some web demos, you can try out the following 🚀 Spaces: | Model | Hugging Face Spaces | |-------------------------------- |------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Text-to-Image Latent Diffusion | [](https://huggingface.co/spaces/CompVis/text2img-latent-diffusion) | | Faces generator | [](https://huggingface.co/spaces/CompVis/celeba-latent-diffusion) | | DDPM with different schedulers | [](https://huggingface.co/spaces/fusing/celeba-diffusion) | | Conditional generation from sketch | [](https://huggingface.co/spaces/huggingface/diffuse-the-rest) | | Composable diffusion | [](https://huggingface.co/spaces/Shuang59/Composable-Diffusion) | ## Definitions **Models**: Neural network that models $p_\theta(\mathbf{x}_{t-1}|\mathbf{x}_t)$ (see image below) and is trained end-to-end to *denoise* a noisy input to an image. *Examples*: UNet, Conditioned UNet, 3D UNet, Transformer UNet <p align="center"> <img src="https://user-images.githubusercontent.com/10695622/174349667-04e9e485-793b-429a-affe-096e8199ad5b.png" width="800"/> <br> <em> Figure from DDPM paper (https://arxiv.org/abs/2006.11239). </em> <p> **Schedulers**: Algorithm class for both **inference** and **training**. The class provides functionality to compute previous image according to alpha, beta schedule as well as predict noise for training. Also known as **Samplers**. *Examples*: [DDPM](https://arxiv.org/abs/2006.11239), [DDIM](https://arxiv.org/abs/2010.02502), [PNDM](https://arxiv.org/abs/2202.09778), [DEIS](https://arxiv.org/abs/2204.13902) <p align="center"> <img src="https://user-images.githubusercontent.com/10695622/174349706-53d58acc-a4d1-4cda-b3e8-432d9dc7ad38.png" width="800"/> <br> <em> Sampling and training algorithms. Figure from DDPM paper (https://arxiv.org/abs/2006.11239). </em> <p> **Diffusion Pipeline**: End-to-end pipeline that includes multiple diffusion models, possible text encoders, ... *Examples*: Glide, Latent-Diffusion, Imagen, DALL-E 2 <p align="center"> <img src="https://user-images.githubusercontent.com/10695622/174348898-481bd7c2-5457-4830-89bc-f0907756f64c.jpeg" width="550"/> <br> <em> Figure from ImageGen (https://imagen.research.google/). </em> <p> ## Philosophy - Readability and clarity is preferred over highly optimized code. A strong importance is put on providing readable, intuitive and elementary code design. *E.g.*, the provided [schedulers](https://github.com/huggingface/diffusers/tree/main/src/diffusers/schedulers) are separated from the provided [models](https://github.com/huggingface/diffusers/tree/main/src/diffusers/models) and provide well-commented code that can be read alongside the original paper. - Diffusers is **modality independent** and focuses on providing pretrained models and tools to build systems that generate **continuous outputs**, *e.g.* vision and audio. - Diffusion models and schedulers are provided as concise, elementary building blocks. In contrast, diffusion pipelines are a collection of end-to-end diffusion systems that can be used out-of-the-box, should stay as close as possible to their original implementation and can include components of another library, such as text-encoders. Examples for diffusion pipelines are [Glide](https://github.com/openai/glide-text2im) and [Latent Diffusion](https://github.com/CompVis/latent-diffusion). ## In the works For the first release, 🤗 Diffusers focuses on text-to-image diffusion techniques. However, diffusers can be used for much more than that! Over the upcoming releases, we'll be focusing on: - Diffusers for audio - Diffusers for reinforcement learning (initial work happening in https://github.com/huggingface/diffusers/pull/105). - Diffusers for video generation - Diffusers for molecule generation (initial work happening in https://github.com/huggingface/diffusers/pull/54) A few pipeline components are already being worked on, namely: - BDDMPipeline for spectrogram-to-sound vocoding - GLIDEPipeline to support OpenAI's GLIDE model - Grad-TTS for text to audio generation / conditional audio generation We want diffusers to be a toolbox useful for diffusers models in general; if you find yourself limited in any way by the current API, or would like to see additional models, schedulers, or techniques, please open a [GitHub issue](https://github.com/huggingface/diffusers/issues) mentioning what you would like to see. ## Credits This library concretizes previous work by many different authors and would not have been possible without their great research and implementations. We'd like to thank, in particular, the following implementations which have helped us in our development and without which the API could not have been as polished today: - @CompVis' latent diffusion models library, available [here](https://github.com/CompVis/latent-diffusion) - @hojonathanho original DDPM implementation, available [here](https://github.com/hojonathanho/diffusion) as well as the extremely useful translation into PyTorch by @pesser, available [here](https://github.com/pesser/pytorch_diffusion) - @ermongroup's DDIM implementation, available [here](https://github.com/ermongroup/ddim). - @yang-song's Score-VE and Score-VP implementations, available [here](https://github.com/yang-song/score_sde_pytorch) We also want to thank @heejkoo for the very helpful overview of papers, code and resources on diffusion models, available [here](https://github.com/heejkoo/Awesome-Diffusion-Models) as well as @crowsonkb and @rromb for useful discussions and insights. ## Citation ```bibtex @misc{von-platen-etal-2022-diffusers, author = {Patrick von Platen and Suraj Patil and Anton Lozhkov and Pedro Cuenca and Nathan Lambert and Kashif Rasul and Mishig Davaadorj and Thomas Wolf}, title = {Diffusers: State-of-the-art diffusion models}, year = {2022}, publisher = {GitHub}, journal = {GitHub repository}, howpublished = {\url{https://github.com/huggingface/diffusers}} } ```

5649976f381a19c93af23495becb8bf5

nateraw/vit-base-patch16-224-cifar10

nateraw

vit

transformers

image-classification

apache-2.0

['cifar10']

['image-classification', 'vision', 'pytorch']

# Vision Transformer Fine Tuned on CIFAR10 Vision Transformer (ViT) model pre-trained on ImageNet-21k (14 million images, 21,843 classes) and **fine-tuned on CIFAR10** at resolution 224x224. Check out the code at my [my Github repo](https://github.com/nateraw/huggingface-vit-finetune). ## Usage ```python from transformers import ViTFeatureExtractor, ViTForImageClassification from PIL import Image import requests url = 'https://www.cs.toronto.edu/~kriz/cifar-10-sample/dog10.png' image = Image.open(requests.get(url, stream=True).raw) feature_extractor = ViTFeatureExtractor.from_pretrained('nateraw/vit-base-patch16-224-cifar10') model = ViTForImageClassification.from_pretrained('nateraw/vit-base-patch16-224-cifar10') inputs = feature_extractor(images=image, return_tensors="pt") outputs = model(**inputs) preds = outputs.logits.argmax(dim=1) classes = [ 'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck' ] classes[preds[0]] ``` ## Model description The Vision Transformer (ViT) is a transformer encoder model (BERT-like) pretrained on a large collection of images in a supervised fashion, namely ImageNet-21k, at a resolution of 224x224 pixels. Images are presented to the model as a sequence of fixed-size patches (resolution 16x16), which are linearly embedded. One also adds a [CLS] token to the beginning of a sequence to use it for classification tasks. One also adds absolute position embeddings before feeding the sequence to the layers of the Transformer encoder. Note that this model does not provide any fine-tuned heads, as these were zero'd by Google researchers. However, the model does include the pre-trained pooler, which can be used for downstream tasks (such as image classification). By pre-training the model, it learns an inner representation of images that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled images for instance, you can train a standard classifier by placing a linear layer on top of the pre-trained encoder. One typically places a linear layer on top of the [CLS] token, as the last hidden state of this token can be seen as a representation of an entire image.

a7720f05c366487247c0c8ddec5f5f70

jeapaul/languagemodel

jeapaul

wav2vec2

transformers

automatic-speech-recognition

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # languagemodel This model is a fine-tuned version of [monideep2255/XLRS-torgo](https://huggingface.co/monideep2255/XLRS-torgo) on an unknown dataset. It achieves the following results on the evaluation set: - Loss: inf - Wer: 1.1173 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 0.0003 - train_batch_size: 16 - eval_batch_size: 8 - seed: 42 - gradient_accumulation_steps: 2 - total_train_batch_size: 32 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - lr_scheduler_warmup_steps: 500 - num_epochs: 30 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | Wer | |:-------------:|:-----:|:----:|:---------------:|:------:| | 2.3015 | 3.12 | 400 | inf | 1.3984 | | 0.6892 | 6.25 | 800 | inf | 1.1059 | | 0.5069 | 9.37 | 1200 | inf | 1.0300 | | 0.3596 | 12.5 | 1600 | inf | 1.0830 | | 0.2571 | 15.62 | 2000 | inf | 1.1981 | | 0.198 | 18.75 | 2400 | inf | 1.1009 | | 0.1523 | 21.87 | 2800 | inf | 1.1803 | | 0.1112 | 25.0 | 3200 | inf | 1.0429 | | 0.08 | 28.12 | 3600 | inf | 1.1173 | ### Framework versions - Transformers 4.23.1 - Pytorch 1.10.0+cu113 - Datasets 1.18.3 - Tokenizers 0.13.1

04bbbdb7edbd59c5b2c31d25803acb7f

Helsinki-NLP/opus-mt-de-efi

Helsinki-NLP

marian

transformers

translation

apache-2.0

['translation']

### opus-mt-de-efi * source languages: de * target languages: efi * OPUS readme: [de-efi](https://github.com/Helsinki-NLP/OPUS-MT-train/blob/master/models/de-efi/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-efi/opus-2020-01-20.zip) * test set translations: [opus-2020-01-20.test.txt](https://object.pouta.csc.fi/OPUS-MT-models/de-efi/opus-2020-01-20.test.txt) * test set scores: [opus-2020-01-20.eval.txt](https://object.pouta.csc.fi/OPUS-MT-models/de-efi/opus-2020-01-20.eval.txt) ## Benchmarks | testset | BLEU | chr-F | |-----------------------|-------|-------| | JW300.de.efi | 24.2 | 0.451 |

78c1aa5620eb159180800cab78b7e81e

Cwhgn/DAMO-YOLO-T

Cwhgn

apache-2.0

[]

## Model Description This **DAMO-YOLO-T** model is a tiny-size object detection model with fast inference speed and high accuracy, trained by **DAMO-YOLO**. DAMO-YOLO is a fast and accurate object detection method, which is developed by TinyML Team from Alibaba DAMO Data Analytics and Intelligence Lab. And it achieves a higher performance than state-of-the-art YOLO series. DAMO-YOLO is extend from YOLO but with some new techs, including Neural Architecture Search (NAS) backbones, efficient Reparameterized Generalized-FPN (RepGFPN), a lightweight head with AlignedOTA label assignment, and distillation enhancement. For more details, please refer to our [Arxiv Report](https://arxiv.org/abs/2211.15444) and [Github Code](https://github.com/tinyvision/DAMO-YOLO). Moreover, here you can find not only powerful models, but also highly efficient training strategies and complete tools from training to deployment. ## Chinese Web Demo - We also provide Chinese Web Demo on ModelScope, including [DAMO-YOLO-T](https://www.modelscope.cn/models/damo/cv_tinynas_object-detection_damoyolo-t/summary), [DAMO-YOLO-S](https://modelscope.cn/models/damo/cv_tinynas_object-detection_damoyolo/summary), [DAMO-YOLO-M](https://www.modelscope.cn/models/damo/cv_tinynas_object-detection_damoyolo-m/summary). ## Datasets The model is trained on COCO2017. ## Model Usage The usage guideline can be found in our [Quick Start Tutorial](https://github.com/tinyvision/DAMO-YOLO). ## Model Evaluation |Model |size |mAP<sup>val<br>0.5:0.95 | Latency T4<br>TRT-FP16-BS1| FLOPs<br>(G)| Params<br>(M)| Download | | ------ |:---: | :---: |:---:|:---: | :---: | :---:| |[DAMO-YOLO-T](./configs/damoyolo_tinynasL20_T.py) | 640 | 41.8 | 2.78 | 18.1 | 8.5 |[torch](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/clean_models/before_distill/damoyolo_tinynasL20_T_418.pth),[onnx](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/onnx/before_distill/damoyolo_tinynasL20_T_418.onnx) | |[DAMO-YOLO-T*](./configs/damoyolo_tinynasL20_T.py) | 640 | 43.0 | 2.78 | 18.1 | 8.5 |[torch](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/clean_models/damoyolo_tinynasL20_T.pth),[onnx](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/onnx/damoyolo_tinynasL20_T.onnx) | |[DAMO-YOLO-S](./configs/damoyolo_tinynasL25_S.py) | 640 | 45.6 | 3.83 | 37.8 | 16.3 |[torch](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/clean_models/before_distill/damoyolo_tinynasL25_S_456.pth),[onnx](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/onnx/before_distill/damoyolo_tinynasL25_S_456.onnx) | |[DAMO-YOLO-S*](./configs/damoyolo_tinynasL25_S.py) | 640 | 46.8 | 3.83 | 37.8 | 16.3 |[torch](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/clean_models/damoyolo_tinynasL25_S.pth),[onnx](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/onnx/damoyolo_tinynasL25_S.onnx) | |[DAMO-YOLO-M](./configs/damoyolo_tinynasL35_M.py) | 640 | 48.7 | 5.62 | 61.8 | 28.2 |[torch](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/clean_models/before_distill/damoyolo_tinynasL35_M_487.pth),[onnx](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/onnx/before_distill/damoyolo_tinynasL35_M_487.onnx)| |[DAMO-YOLO-M*](./configs/damoyolo_tinynasL35_M.py) | 640 | 50.0 | 5.62 | 61.8 | 28.2 |[torch](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/clean_models/damoyolo_tinynasL35_M.pth),[onnx](https://idstcv.oss-cn-zhangjiakou.aliyuncs.com/DAMO-YOLO/onnx/damoyolo_tinynasL35_M.onnx)| - We report the mAP of models on COCO2017 validation set, with multi-class NMS. - The latency in this table is measured without post-processing. - \* denotes the model trained with distillation. ## Cite DAMO-YOLO If you use DAMO-YOLO in your research, please cite our work by using the following BibTeX entry: ```latex @article{damoyolo, title={DAMO-YOLO: A Report on Real-Time Object Detection Design}, author={Xianzhe Xu, Yiqi Jiang, Weihua Chen, Yilun Huang, Yuan Zhang and Xiuyu Sun}, journal={arXiv preprint arXiv:2211.15444v2}, year={2022}, } ```

2b6545482d3b485a60db785e800a5f36

espnet/realzza-meld-asr-hubert-transformer

espnet

espnet

automatic-speech-recognition

cc-by-4.0

['en']

['meld']

['espnet', 'audio', 'automatic-speech-recognition', 'spoken-language-understanding']

# ESPnet2: Meld Recipe ## Demo: How to use in ESPnet2 ```bash cd espnet pip install -e . cd egs2/meld/asr1/ ./run.sh ``` ## Environments - date: `Thu Nov 10 09:07:40 EST 2022` - python version: `3.8.6 (default, Dec 17 2020, 16:57:01) [GCC 10.2.0]` - espnet version: `espnet 202207` - pytorch version: `pytorch 1.8.1+cu102` - Git hash: `a7bd6522b32ec6472c13f6a2289dcdff4a846c12` - Commit date: `Wed Sep 14 08:34:27 2022 -0400` ## asr_train_asr_hubert_transformer_adam_specaug_meld_raw_en_bpe850 - ASR config: conf/tuning/train_asr_hubert_transformer_adam_specaug_meld.yaml - token_type: bpe - keep_nbest_models: 5 |dataset|Snt|Emotion Classification (%)| |---|---|---| |decoder_asr_asr_model_valid.acc.ave_5best/test|2608|39.22| |decoder_asr_asr_model_valid.acc.ave_5best/valid|1104|42.64| ### ASR results #### WER |dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err| |---|---|---|---|---|---|---|---|---| |decoder_asr_asr_model_valid.acc.ave_5best/test|2608|24809|55.5|28.0|16.5|8.4|52.9|96.5| |decoder_asr_asr_model_valid.acc.ave_5best/valid|1104|10171|55.3|29.4|15.3|7.0|51.7|96.2| #### CER |dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err| |---|---|---|---|---|---|---|---|---| |decoder_asr_asr_model_valid.acc.ave_5best/test|2608|120780|71.1|10.7|18.2|10.6|39.5|96.5| |decoder_asr_asr_model_valid.acc.ave_5best/valid|1104|49323|71.3|11.1|17.6|9.4|38.1|96.2| #### TER |dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err| |---|---|---|---|---|---|---|---|---| |decoder_asr_asr_model_valid.acc.ave_5best/test|2608|35287|57.6|21.8|20.5|7.8|50.2|96.5| |decoder_asr_asr_model_valid.acc.ave_5best/valid|1104|14430|57.4|23.2|19.4|6.1|48.6|96.2|

7519deaf7b47d3610deb6a523d6f610e

gorkemgoknar/gpt2-small-turkish

gorkemgoknar

gpt2

transformers

text-generation

apache-2.0

['tr']

['wikipedia-turkish']

['gpt2', 'turkish']

# Turkish GPT2 Model Finetuned # Türkçe GPT2 Modeli ## Model description This is a GPT2-Small English based model finetuned and additionaly trainied with Wikipedia Articles in Turkish as of 28-10-2020 Live demo based on this work at : https://www.metayazar.com/ Fine tuned writer on this model: https://huggingface.co/gorkemgoknar/gpt2-turkish-writer Work has been done on Pierre Guillou tutorial as on this page. (https://github.com/piegu/fastai-projects/blob/master/finetuning-English-GPT2-any-language-Portuguese-HuggingFace-fastaiv2.ipynb) Code is converted to work with Fastai 2.X . Using Google Colab for training. Additional tutorial and source will be in https://github.com/gorkemgoknar in later stage. Current accuracy 33 % , Perplexity : 51.88 Models are available: * [gpt2-small-tuned-tr] (https://huggingface.co/gorkemgoknar/gpt2-small-turkish) * [gpt2-small-turkish-writer] (https://huggingface.co/gorkemgoknar/gpt2-turkish-writer) ## Intended uses & limitations #### How to use #### Install ```python from transformers import AutoTokenizer, AutoModelWithLMHead import torch tokenizer = AutoTokenizer.from_pretrained("gorkemgoknar/gpt2-small-turkish") model = AutoModelWithLMHead.from_pretrained("gorkemgoknar/gpt2-small-turkish") # Get sequence length max of 1024 tokenizer.model_max_length=1024 model.eval() # disable dropout (or leave in train mode to finetune) ``` #### Generate 1 word ```python # input sequence text = "Bu yazıyı bilgisayar yazdı." inputs = tokenizer(text, return_tensors="pt") # model output outputs = model(**inputs, labels=inputs["input_ids"]) loss, logits = outputs[:2] predicted_index = torch.argmax(logits[0, -1, :]).item() predicted_text = tokenizer.decode([predicted_index]) # results print('input text:', text) print('predicted text:', predicted_text) # input text: # predicted text: ``` #### Generate Full Sequence ```python # input sequence text = "Bu yazıyı bilgisayar yazdı." inputs = tokenizer(text, return_tensors="pt") # model output using Top-k sampling text generation method sample_outputs = model.generate(inputs.input_ids, pad_token_id=50256, do_sample=True, max_length=50, # put the token number you want top_k=40, num_return_sequences=1) # generated sequence for i, sample_output in enumerate(sample_outputs): print(">> Generated text {}\\\\ \\\\ {}".format(i+1, tokenizer.decode(sample_output.tolist()))) # >> Generated text # ``` #### Limitations and bias The training data used for this model come from Turkish Wikipedia. We know it contains a lot of unfiltered content from the internet, which is far from neutral. ## Training data Wikipedia Turkish article dump as of 28-10-2020 ## Training procedure ## Eval results | epoch\\\\t|train_loss\\\\t|valid_loss\\\\t|accuracy\\\\t|perplexity\\\\t|time | | ----- | -------- |--------- | ---------- | --------- | ----- | |0\\\\t|4.777015\\\\t|4.621834\\\\t|0.292547\\\\t|101.680367\\\\t|2:42:05| |1\\\\t|4.509412\\\\t|4.403999\\\\t|0.305574\\\\t|81.777267\\\\t|1:09:38| |2\\\\t|4.169529\\\\t|4.120755\\\\t|0.324908\\\\t|61.605747\\\\t|1:07:45| |3\\\\t|4.293973\\\\t|4.177899\\\\t|0.317211\\\\t|65.228653\\\\t|1:07:02| |4\\\\t|4.049848\\\\t|3.949103\\\\t|0.338347\\\\t|51.888783\\\\t|1:05:53| #Epoch 0 on Tesla T4, others on V100 ```

45f1507b46de4efe36497523568a73a3

davanstrien/distilbert-base-cased_fine_tuned_food_ner

davanstrien

distilbert

transformers

token-classification

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # distilbert-base-cased_fine_tuned_food_ner This model is a fine-tuned version of [distilbert-base-cased](https://huggingface.co/distilbert-base-cased) on the None dataset. It achieves the following results on the evaluation set: - Loss: 0.6129 - Precision: 0.9080 - Recall: 0.9328 - F1: 0.9203 - Accuracy: 0.9095 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-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: 50 ### Training results | Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1 | Accuracy | |:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:| | No log | 1.0 | 40 | 1.2541 | 0.7806 | 0.7299 | 0.7544 | 0.6782 | | No log | 2.0 | 80 | 0.7404 | 0.8301 | 0.8657 | 0.8475 | 0.8047 | | No log | 3.0 | 120 | 0.5886 | 0.8416 | 0.8900 | 0.8651 | 0.8507 | | No log | 4.0 | 160 | 0.5094 | 0.8772 | 0.9122 | 0.8944 | 0.8727 | | No log | 5.0 | 200 | 0.4724 | 0.8727 | 0.9159 | 0.8938 | 0.8863 | | No log | 6.0 | 240 | 0.4471 | 0.8975 | 0.9240 | 0.9105 | 0.8960 | | No log | 7.0 | 280 | 0.4446 | 0.9028 | 0.9255 | 0.9140 | 0.9006 | | No log | 8.0 | 320 | 0.4437 | 0.9042 | 0.9336 | 0.9187 | 0.9032 | | No log | 9.0 | 360 | 0.4582 | 0.9144 | 0.9299 | 0.9221 | 0.9074 | | No log | 10.0 | 400 | 0.4525 | 0.9080 | 0.9328 | 0.9203 | 0.9066 | | No log | 11.0 | 440 | 0.4650 | 0.9076 | 0.9351 | 0.9211 | 0.9032 | | No log | 12.0 | 480 | 0.4725 | 0.9119 | 0.9395 | 0.9255 | 0.9095 | | 0.406 | 13.0 | 520 | 0.4862 | 0.9161 | 0.9343 | 0.9251 | 0.9095 | | 0.406 | 14.0 | 560 | 0.4735 | 0.9214 | 0.9424 | 0.9318 | 0.9154 | | 0.406 | 15.0 | 600 | 0.4973 | 0.9085 | 0.9380 | 0.9230 | 0.9095 | | 0.406 | 16.0 | 640 | 0.5075 | 0.9026 | 0.9373 | 0.9196 | 0.9099 | | 0.406 | 17.0 | 680 | 0.5057 | 0.9124 | 0.9380 | 0.9250 | 0.9121 | | 0.406 | 18.0 | 720 | 0.5179 | 0.9098 | 0.9380 | 0.9237 | 0.9129 | | 0.406 | 19.0 | 760 | 0.5156 | 0.9111 | 0.9380 | 0.9244 | 0.9121 | | 0.406 | 20.0 | 800 | 0.5325 | 0.9077 | 0.9358 | 0.9215 | 0.9099 | | 0.406 | 21.0 | 840 | 0.5350 | 0.9203 | 0.9373 | 0.9287 | 0.9137 | | 0.406 | 22.0 | 880 | 0.5405 | 0.9077 | 0.9365 | 0.9219 | 0.9108 | | 0.406 | 23.0 | 920 | 0.5682 | 0.9107 | 0.9336 | 0.9220 | 0.9066 | | 0.406 | 24.0 | 960 | 0.5545 | 0.9109 | 0.9351 | 0.9228 | 0.9095 | | 0.0303 | 25.0 | 1000 | 0.5717 | 0.9044 | 0.9351 | 0.9194 | 0.9049 | | 0.0303 | 26.0 | 1040 | 0.5637 | 0.9101 | 0.9343 | 0.9221 | 0.9108 | | 0.0303 | 27.0 | 1080 | 0.5736 | 0.9102 | 0.9351 | 0.9225 | 0.9104 | | 0.0303 | 28.0 | 1120 | 0.5793 | 0.9027 | 0.9380 | 0.9200 | 0.9074 | | 0.0303 | 29.0 | 1160 | 0.5753 | 0.9137 | 0.9380 | 0.9257 | 0.9112 | | 0.0303 | 30.0 | 1200 | 0.5804 | 0.9111 | 0.9380 | 0.9244 | 0.9108 | | 0.0303 | 31.0 | 1240 | 0.5877 | 0.9123 | 0.9365 | 0.9243 | 0.9099 | | 0.0303 | 32.0 | 1280 | 0.5837 | 0.9116 | 0.9358 | 0.9235 | 0.9087 | | 0.0303 | 33.0 | 1320 | 0.5886 | 0.9113 | 0.9402 | 0.9255 | 0.9108 | | 0.0303 | 34.0 | 1360 | 0.5847 | 0.9145 | 0.9387 | 0.9264 | 0.9121 | | 0.0303 | 35.0 | 1400 | 0.5981 | 0.9083 | 0.9358 | 0.9218 | 0.9082 | | 0.0303 | 36.0 | 1440 | 0.5963 | 0.9056 | 0.9343 | 0.9197 | 0.9095 | | 0.0303 | 37.0 | 1480 | 0.6027 | 0.9101 | 0.9343 | 0.9221 | 0.9104 | | 0.0086 | 38.0 | 1520 | 0.6003 | 0.9102 | 0.9351 | 0.9225 | 0.9099 | | 0.0086 | 39.0 | 1560 | 0.5958 | 0.9082 | 0.9343 | 0.9211 | 0.9095 | | 0.0086 | 40.0 | 1600 | 0.6054 | 0.9059 | 0.9306 | 0.9181 | 0.9091 | | 0.0086 | 41.0 | 1640 | 0.6056 | 0.9075 | 0.9343 | 0.9207 | 0.9112 | | 0.0086 | 42.0 | 1680 | 0.6029 | 0.9080 | 0.9321 | 0.9199 | 0.9091 | | 0.0086 | 43.0 | 1720 | 0.6027 | 0.9109 | 0.9351 | 0.9228 | 0.9104 | | 0.0086 | 44.0 | 1760 | 0.6071 | 0.9075 | 0.9336 | 0.9203 | 0.9099 | | 0.0086 | 45.0 | 1800 | 0.6100 | 0.9102 | 0.9351 | 0.9225 | 0.9095 | | 0.0086 | 46.0 | 1840 | 0.6106 | 0.9102 | 0.9351 | 0.9225 | 0.9104 | | 0.0086 | 47.0 | 1880 | 0.6132 | 0.9101 | 0.9343 | 0.9221 | 0.9091 | | 0.0086 | 48.0 | 1920 | 0.6134 | 0.9095 | 0.9343 | 0.9217 | 0.9095 | | 0.0086 | 49.0 | 1960 | 0.6129 | 0.9080 | 0.9328 | 0.9203 | 0.9095 | | 0.005 | 50.0 | 2000 | 0.6129 | 0.9080 | 0.9328 | 0.9203 | 0.9095 | ### Framework versions - Transformers 4.21.0 - Pytorch 1.12.0+cu113 - Datasets 2.4.0 - Tokenizers 0.12.1

dfc415a57928faeff60711e7d211362a

yip-i/wav2vec2-demo-F04-2

yip-i

wav2vec2

transformers

automatic-speech-recognition

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # wav2vec2-demo-F04-2 This model is a fine-tuned version of [facebook/wav2vec2-large-xlsr-53](https://huggingface.co/facebook/wav2vec2-large-xlsr-53) on the None dataset. It achieves the following results on the evaluation set: - Loss: 0.3203 - Wer: 0.5353 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 0.0001 - 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: 1000 - num_epochs: 30 ### Training results | Training Loss | Epoch | Step | Validation Loss | Wer | |:-------------:|:-----:|:-----:|:---------------:|:------:| | 23.5576 | 0.89 | 500 | 3.3654 | 1.0 | | 3.3953 | 1.79 | 1000 | 3.1729 | 1.0 | | 2.9514 | 2.68 | 1500 | 2.8946 | 1.0 | | 2.84 | 3.57 | 2000 | 2.8386 | 1.0 | | 2.7685 | 4.46 | 2500 | 2.7147 | 1.0 | | 2.5059 | 5.36 | 3000 | 2.1341 | 1.1752 | | 1.8907 | 6.25 | 3500 | 1.3604 | 1.2403 | | 1.3892 | 7.14 | 4000 | 0.8814 | 1.1989 | | 1.0754 | 8.04 | 4500 | 0.6416 | 1.0529 | | 0.8795 | 8.93 | 5000 | 0.5760 | 0.9641 | | 0.7478 | 9.82 | 5500 | 0.4633 | 0.8790 | | 0.6107 | 10.71 | 6000 | 0.3921 | 0.8394 | | 0.5445 | 11.61 | 6500 | 0.3579 | 0.7987 | | 0.4788 | 12.5 | 7000 | 0.3034 | 0.7470 | | 0.4435 | 13.39 | 7500 | 0.2989 | 0.7311 | | 0.4057 | 14.29 | 8000 | 0.3366 | 0.7092 | | 0.3606 | 15.18 | 8500 | 0.2783 | 0.6892 | | 0.343 | 16.07 | 9000 | 0.2593 | 0.6612 | | 0.3189 | 16.96 | 9500 | 0.2780 | 0.6460 | | 0.277 | 17.86 | 10000 | 0.3266 | 0.6277 | | 0.2789 | 18.75 | 10500 | 0.3582 | 0.6253 | | 0.2552 | 19.64 | 11000 | 0.3422 | 0.6156 | | 0.2416 | 20.54 | 11500 | 0.3387 | 0.6016 | | 0.2187 | 21.43 | 12000 | 0.3657 | 0.5845 | | 0.2317 | 22.32 | 12500 | 0.2932 | 0.5845 | | 0.2091 | 23.21 | 13000 | 0.2551 | 0.5614 | | 0.199 | 24.11 | 13500 | 0.3113 | 0.5474 | | 0.1777 | 25.0 | 14000 | 0.2895 | 0.5572 | | 0.1823 | 25.89 | 14500 | 0.3127 | 0.5456 | | 0.179 | 26.79 | 15000 | 0.2945 | 0.5438 | | 0.1596 | 27.68 | 15500 | 0.3052 | 0.5322 | | 0.1671 | 28.57 | 16000 | 0.3119 | 0.5365 | | 0.1564 | 29.46 | 16500 | 0.3203 | 0.5353 | ### Framework versions - Transformers 4.23.1 - Pytorch 1.12.1+cu113 - Datasets 1.18.3 - Tokenizers 0.13.2

9611873b854e5b846fc5f901066a2684

rajistics/informal_formal_style_transfer

rajistics

t5

transformers

text2text-generation

apache-2.0

['en']

[]

## Source A Neural Language Style Transfer framework to transfer natural language text smoothly between fine-grained language styles like formal/casual. The original model is at [https://github.com/PrithivirajDamodaran/Styleformer](https://github.com/PrithivirajDamodaran/Styleformer).  ## Examples: ``` [Casual] I am quitting my job [Formal] I will be stepping down from my job. ---------------------------------------------------------------------------------------------------- [Casual] Jimmy is on crack and can't trust him [Formal] Jimmy is a crack addict I cannot trust him ---------------------------------------------------------------------------------------------------- [Casual] What do guys do to show that they like a gal? [Formal] What do guys do to demonstrate their affinity for women? ---------------------------------------------------------------------------------------------------- [Casual] i loooooooooooooooooooooooove going to the movies. [Formal] I really like to go to the movies. ``` ## References - [Formality Style Transfer for Noisy Text: Leveraging Out-of-Domain Parallel Data for In-Domain Training via POS Masking](https://www.aclweb.org/anthology/D19-5502.pdf) - [Generative Text Style Transfer for Improved Language Sophistication](http://cs230.stanford.edu/projects_winter_2020/reports/32069807.pdf) - [Delete, Retrieve, Generate: A Simple Approach to Sentiment and Style Transfer](https://arxiv.org/pdf/1804.06437.pdf)

3e92178b50846e4c0e85b6bddc271780

imvladikon/wav2vec2-xls-r-300m-lm-hebrew

imvladikon

wav2vec2

transformers

automatic-speech-recognition

apache-2.0

['generated_from_trainer', 'he', 'robust-speech-event']

# wav2vec2-xls-r-300m-lm-hebrew This model is a fine-tuned version of [facebook/wav2vec2-xls-r-300m](https://huggingface.co/facebook/wav2vec2-xls-r-300m) on the None dataset with adding ngram models according to [Boosting Wav2Vec2 with n-grams in 🤗 Transformers](https://huggingface.co/blog/wav2vec2-with-ngram) ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 0.0003 - train_batch_size: 64 - eval_batch_size: 16 - seed: 42 - gradient_accumulation_steps: 2 - total_train_batch_size: 128 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - lr_scheduler_warmup_steps: 500 - num_epochs: 100 - mixed_precision_training: Native AMP ### Training results ### Framework versions - Transformers 4.16.0.dev0 - Pytorch 1.10.1+cu102 - Datasets 1.17.1.dev0 - Tokenizers 0.11.0

dd0b6d26ec6bd6985c2566c9b1b831b5

TencentMedicalNet/MedicalNet-Resnet10

TencentMedicalNet

mit

['en']

['MRBrainS18']

['MedicalNet', 'medical images', 'medical', '3D', 'Med3D']

# MedicalNet This repository contains a Pytorch implementation of [Med3D: Transfer Learning for 3D Medical Image Analysis](https://arxiv.org/abs/1904.00625). Many studies have shown that the performance on deep learning is significantly affected by volume of training data. The MedicalNet project aggregated the dataset with diverse modalities, target organs, and pathologies to to build relatively large datasets. Based on this dataset, a series of 3D-ResNet pre-trained models and corresponding transfer-learning training code are provided. ### License MedicalNet is released under the MIT License (refer to the LICENSE file for detailso). ### Citing MedicalNet If you use this code or pre-trained models, please cite the following: ``` @article{chen2019med3d, title={Med3D: Transfer Learning for 3D Medical Image Analysis}, author={Chen, Sihong and Ma, Kai and Zheng, Yefeng}, journal={arXiv preprint arXiv:1904.00625}, year={2019} } ``` ### Update(2019/07/30) We uploaded 4 pre-trained models based on more datasets (23 datasets). ``` Model name : parameters settings resnet_10_23dataset.pth: --model resnet --model_depth 10 --resnet_shortcut B resnet_18_23dataset.pth: --model resnet --model_depth 18 --resnet_shortcut A resnet_34_23dataset.pth: --model resnet --model_depth 34 --resnet_shortcut A resnet_50_23dataset.pth: --model resnet --model_depth 50 --resnet_shortcut B ``` Hugging Face repository contribution by: [Rafael Zimmer](https://www.github.com/rzimmerdev)

3b78cd30983091b59fd000537cc9ab87

danieleV9H/hubert-base-libri-clean-ft100h

danieleV9H

hubert

transformers

automatic-speech-recognition

apache-2.0

['librispeech_asr']

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # hubert-base-libri-clean-ft100h This model is a fine-tuned version of [facebook/hubert-base-ls960](https://huggingface.co/facebook/hubert-base-ls960) on the librispeech_asr dataset. It achieves the following results on the evaluation set: - Loss: 0.1324 - Wer: 0.1597 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - train_batch_size: 8 - eval_batch_size: 16 - seed: 42 - gradient_accumulation_steps: 2 - 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: 1000 - num_epochs: 5 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | Wer | |:-------------:|:-----:|:----:|:---------------:|:------:| | No log | 0.14 | 250 | 4.1508 | 1.0000 | | 4.4345 | 0.28 | 500 | 3.8766 | 1.0000 | | 4.4345 | 0.42 | 750 | 3.4376 | 1.0000 | | 2.8475 | 0.56 | 1000 | 2.7380 | 1.0 | | 2.8475 | 0.7 | 1250 | 0.8803 | 0.6766 | | 1.1877 | 0.84 | 1500 | 0.5671 | 0.5102 | | 1.1877 | 0.98 | 1750 | 0.4537 | 0.4388 | | 0.5802 | 1.12 | 2000 | 0.3566 | 0.3740 | | 0.5802 | 1.26 | 2250 | 0.2925 | 0.3209 | | 0.4301 | 1.4 | 2500 | 0.2613 | 0.2952 | | 0.4301 | 1.54 | 2750 | 0.2363 | 0.2715 | | 0.3591 | 1.68 | 3000 | 0.2155 | 0.2552 | | 0.3591 | 1.82 | 3250 | 0.2062 | 0.2418 | | 0.3015 | 1.96 | 3500 | 0.1951 | 0.2308 | | 0.3015 | 2.1 | 3750 | 0.1842 | 0.2207 | | 0.2698 | 2.24 | 4000 | 0.1900 | 0.2112 | | 0.2698 | 2.38 | 4250 | 0.1745 | 0.2048 | | 0.2561 | 2.52 | 4500 | 0.1718 | 0.2040 | | 0.2561 | 2.66 | 4750 | 0.1625 | 0.1939 | | 0.2348 | 2.8 | 5000 | 0.1568 | 0.1867 | | 0.2348 | 2.94 | 5250 | 0.1517 | 0.1855 | | 0.2278 | 3.08 | 5500 | 0.1501 | 0.1807 | | 0.2278 | 3.22 | 5750 | 0.1445 | 0.1772 | | 0.2166 | 3.36 | 6000 | 0.1422 | 0.1752 | | 0.2166 | 3.5 | 6250 | 0.1418 | 0.1741 | | 0.2017 | 3.64 | 6500 | 0.1404 | 0.1695 | | 0.2017 | 3.78 | 6750 | 0.1356 | 0.1674 | | 0.1922 | 3.92 | 7000 | 0.1350 | 0.1688 | | 0.1922 | 4.06 | 7250 | 0.1346 | 0.1638 | | 0.1979 | 4.2 | 7500 | 0.1359 | 0.1638 | | 0.1979 | 4.34 | 7750 | 0.1336 | 0.1612 | | 0.1836 | 4.48 | 8000 | 0.1324 | 0.1613 | | 0.1836 | 4.62 | 8250 | 0.1320 | 0.1606 | | 0.1891 | 4.76 | 8500 | 0.1325 | 0.1598 | | 0.1891 | 4.9 | 8750 | 0.1324 | 0.1597 | ### Framework versions - Transformers 4.17.0 - Pytorch 1.11.0+cu113 - Datasets 1.18.3 - Tokenizers 0.12.1

8324194e16045b7cc5cddb2ba388c513

DrishtiSharma/whisper-large-v2-hungarian-400-steps

DrishtiSharma

whisper

transformers

automatic-speech-recognition

apache-2.0

['hu']

['mozilla-foundation/common_voice_11_0']

['whisper-event', 'generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # Whisper Large Nepali - Drishti Sharma This model is a fine-tuned version of [openai/whisper-small](https://huggingface.co/openai/whisper-small) on the Common Voice 11.0 dataset. It achieves the following results on the evaluation set: - Loss: 0.2551 - Wer: 18.8467 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 1e-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: 100 - training_steps: 400 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | Wer | |:-------------:|:-----:|:----:|:---------------:|:-------:| | 0.2613 | 0.27 | 400 | 0.2551 | 18.8467 | ### Framework versions - Transformers 4.26.0.dev0 - Pytorch 1.13.0+cu116 - Datasets 2.7.1.dev0 - Tokenizers 0.13.2

13caa302125caf15f8975418c5c656a6

paola-md/recipe-lr1e05-wd0.01-bs16

paola-md

roberta

transformers

text-classification

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # recipe-lr1e05-wd0.01-bs16 This model is a fine-tuned version of [paola-md/recipe-distilroberta-Is](https://huggingface.co/paola-md/recipe-distilroberta-Is) on the None dataset. It achieves the following results on the evaluation set: - Loss: 0.2793 - Rmse: 0.5285 - Mse: 0.2793 - Mae: 0.4342 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 1e-05 - train_batch_size: 128 - eval_batch_size: 128 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 10 ### Training results | Training Loss | Epoch | Step | Validation Loss | Rmse | Mse | Mae | |:-------------:|:-----:|:----:|:---------------:|:------:|:------:|:------:| | 0.2767 | 1.0 | 1245 | 0.2744 | 0.5239 | 0.2744 | 0.4124 | | 0.2739 | 2.0 | 2490 | 0.2757 | 0.5251 | 0.2757 | 0.4212 | | 0.2727 | 3.0 | 3735 | 0.2793 | 0.5285 | 0.2793 | 0.4342 | ### Framework versions - Transformers 4.19.0.dev0 - Pytorch 1.9.0+cu111 - Datasets 2.4.0 - Tokenizers 0.12.1

658cadc2476f5c2ef3581b45b0ea7834

sentence-transformers/bert-base-nli-max-tokens

sentence-transformers

bert

sentence-transformers

sentence-similarity

apache-2.0

['sentence-transformers', 'feature-extraction', 'sentence-similarity', 'transformers']

**⚠️ This model is deprecated. Please don't use it as it produces sentence embeddings of low quality. You can find recommended sentence embedding models here: [SBERT.net - Pretrained Models](https://www.sbert.net/docs/pretrained_models.html)** # sentence-transformers/bert-base-nli-max-tokens This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 768 dimensional dense vector space and can be used for tasks like clustering or semantic search. ## Usage (Sentence-Transformers) Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed: ``` pip install -U sentence-transformers ``` Then you can use the model like this: ```python from sentence_transformers import SentenceTransformer sentences = ["This is an example sentence", "Each sentence is converted"] model = SentenceTransformer('sentence-transformers/bert-base-nli-max-tokens') embeddings = model.encode(sentences) print(embeddings) ``` ## Usage (HuggingFace Transformers) Without [sentence-transformers](https://www.SBERT.net), you can use the model like this: First, you pass your input through the transformer model, then you have to apply the right pooling-operation on-top of the contextualized word embeddings. ```python from transformers import AutoTokenizer, AutoModel import torch # Max Pooling - Take the max value over time for every dimension. def max_pooling(model_output, attention_mask): token_embeddings = model_output[0] #First element of model_output contains all token embeddings input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float() token_embeddings[input_mask_expanded == 0] = -1e9 # Set padding tokens to large negative value return torch.max(token_embeddings, 1)[0] # Sentences we want sentence embeddings for sentences = ['This is an example sentence', 'Each sentence is converted'] # Load model from HuggingFace Hub tokenizer = AutoTokenizer.from_pretrained('sentence-transformers/bert-base-nli-max-tokens') model = AutoModel.from_pretrained('sentence-transformers/bert-base-nli-max-tokens') # Tokenize sentences encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt') # Compute token embeddings with torch.no_grad(): model_output = model(**encoded_input) # Perform pooling. In this case, max pooling. sentence_embeddings = max_pooling(model_output, encoded_input['attention_mask']) print("Sentence embeddings:") print(sentence_embeddings) ``` ## Evaluation Results For an automated evaluation of this model, see the *Sentence Embeddings Benchmark*: [https://seb.sbert.net](https://seb.sbert.net?model_name=sentence-transformers/bert-base-nli-max-tokens) ## Full Model Architecture ``` SentenceTransformer( (0): Transformer({'max_seq_length': 128, 'do_lower_case': False}) with Transformer model: BertModel (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': False, 'pooling_mode_max_tokens': True, 'pooling_mode_mean_sqrt_len_tokens': False}) ) ``` ## Citing & Authors This model was trained by [sentence-transformers](https://www.sbert.net/). If you find this model helpful, feel free to cite our publication [Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks](https://arxiv.org/abs/1908.10084): ```bibtex @inproceedings{reimers-2019-sentence-bert, title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks", author = "Reimers, Nils and Gurevych, Iryna", booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing", month = "11", year = "2019", publisher = "Association for Computational Linguistics", url = "http://arxiv.org/abs/1908.10084", } ```

01424900dc45c408817091f060f291da

kha-white/manga-ocr-base

kha-white

vision-encoder-decoder

transformers

image-to-text

apache-2.0

['ja']

['manga109s']

['image-to-text']

# Manga OCR Optical character recognition for Japanese text, with the main focus being Japanese manga. It uses [Vision Encoder Decoder](https://huggingface.co/docs/transformers/model_doc/vision-encoder-decoder) framework. Manga OCR can be used as a general purpose printed Japanese OCR, but its main goal was to provide a high quality text recognition, robust against various scenarios specific to manga: - both vertical and horizontal text - text with furigana - text overlaid on images - wide variety of fonts and font styles - low quality images Code is available [here](https://github.com/kha-white/manga_ocr).

01ad2a2f436ea34209d9527bd1aa6468

xliu128/xlm-roberta-base-finetuned-panx-de

xliu128

xlm-roberta

transformers

token-classification

mit

['xtreme']

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # xlm-roberta-base-finetuned-panx-de This model is a fine-tuned version of [xlm-roberta-base](https://huggingface.co/xlm-roberta-base) on the xtreme dataset. It achieves the following results on the evaluation set: - Loss: 0.1363 - F1: 0.8627 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - train_batch_size: 24 - eval_batch_size: 24 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 3 ### Training results | Training Loss | Epoch | Step | Validation Loss | F1 | |:-------------:|:-----:|:----:|:---------------:|:------:| | 0.2539 | 1.0 | 525 | 0.1697 | 0.8179 | | 0.1317 | 2.0 | 1050 | 0.1327 | 0.8516 | | 0.0819 | 3.0 | 1575 | 0.1363 | 0.8627 | ### Framework versions - Transformers 4.11.3 - Pytorch 1.11.0+cu113 - Datasets 1.16.1 - Tokenizers 0.10.3

e8ba46ccc2397d2774a76da7f86d30d6

wdcqc/starcraft-platform-terrain-32x32

wdcqc

diffusers

other

creativeml-openrail-m

['wdcqc/starcraft-remastered-melee-maps']

['pytorch', 'diffusers', 'stable-diffusion', 'text-to-image', 'diffusion-models-class', 'dreambooth-hackathon', 'landscape']

# DreamBooth model for Starcraft:Remastered terrain This is a Stable Diffusion model fine-tuned on Starcraft terrain images on the Space Platform tileset with DreamBooth. It can be used by adding the `instance_prompt`: **isometric scspace terrain** It was trained on 32x32 terrain images from 265 melee maps including original Blizzard maps and those downloaded from Battle.net, scmscx.com and broodwarmaps.net. Run it on Huggingface Spaces: https://huggingface.co/spaces/wdcqc/wfd Or use this notebook on Colab: https://colab.research.google.com/github/wdcqc/WaveFunctionDiffusion/blob/remaster/colab/WaveFunctionDiffusion_Demo.ipynb In addition to Dreambooth, a custom VAE model (`AutoencoderTile`) is trained to encode and decode the latents to/from tileset probabilities ("waves") and then generated as Starcraft maps. A WFC Guidance, inspired by the Wave Function Collapse algorithm, is also added to the pipeline. For more information about guidance please see this page: [Fine-Tuning, Guidance and Conditioning](https://github.com/huggingface/diffusion-models-class/tree/main/unit2) This model was created as part of the DreamBooth Hackathon. Visit the [organisation page](https://huggingface.co/dreambooth-hackathon) for instructions on how to take part! ## Description This is a Stable Diffusion model fine-tuned on starcraft terrain images for the landscape theme. GitHub: https://github.com/wdcqc/WaveFunctionDiffusion ## Usage First clone the git repository: ```bash git clone https://github.com/wdcqc/WaveFunctionDiffusion.git ``` Then create a Jupyter notebook under the repository folder: ```python # Load pipeline from wfd.wf_diffusers import WaveFunctionDiffusionPipeline from wfd.wf_diffusers import AutoencoderTile wfc_data_path = "tile_data/wfc/platform_32x32.npz" # Use CUDA (otherwise it will take 15 minutes) device = "cuda" tilenet = AutoencoderTile.from_pretrained( "wdcqc/starcraft-platform-terrain-32x32", subfolder="tile_vae" ).to(device) pipeline = WaveFunctionDiffusionPipeline.from_pretrained( "wdcqc/starcraft-platform-terrain-32x32", tile_vae = tilenet, wfc_data_path = wfc_data_path ) pipeline.to(device) # Generate pipeline output # need to include the dreambooth keyword "isometric scspace terrain" pipeline_output = pipeline( "isometric scspace terrain, corgi", num_inference_steps = 50, wfc_guidance_start_step = 20, wfc_guidance_strength = 5, wfc_guidance_final_steps = 20, wfc_guidance_final_strength = 10, ) image = pipeline_output.images[0] # Display raw generated image from IPython.display import display display(image) # Display generated image as tiles wave = pipeline_output.waves[0] tile_result = wave.argmax(axis=2) from wfd.scmap import demo_map_image display(demo_map_image(tile_result, wfc_data_path = wfc_data_path)) # Generate map file from wfd.scmap import tiles_to_scx import random, time tiles_to_scx( tile_result, "outputs/generated_{}_{:04d}.scx".format(time.strftime("%Y%m%d_%H%M%S"), random.randint(0, 1e4)), wfc_data_path = wfc_data_path ) # Open the generated map file in `outputs` folder with Scmdraft 2 ```

14350a45f4811851417304f551104815

jperezv/bert-finetuned-ner

jperezv

bert

transformers

token-classification

apache-2.0

['conll2003']

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # bert-finetuned-ner This model is a fine-tuned version of [bert-base-cased](https://huggingface.co/bert-base-cased) on the conll2003 dataset. It achieves the following results on the evaluation set: - Loss: 0.0627 - Precision: 0.9389 - Recall: 0.9524 - F1: 0.9456 - Accuracy: 0.9866 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-05 - 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 - num_epochs: 3 ### Training results | Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1 | Accuracy | |:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:| | 0.0835 | 1.0 | 1756 | 0.0711 | 0.9200 | 0.9334 | 0.9266 | 0.9825 | | 0.0329 | 2.0 | 3512 | 0.0648 | 0.9308 | 0.9485 | 0.9396 | 0.9858 | | 0.0179 | 3.0 | 5268 | 0.0627 | 0.9389 | 0.9524 | 0.9456 | 0.9866 | ### Framework versions - Transformers 4.20.1 - Pytorch 1.12.0+cu113 - Datasets 2.4.0 - Tokenizers 0.12.1

113e53e09798f02595c30622bb91e235

yanaiela/roberta-base-epoch_69

yanaiela

roberta

transformers

fill-mask

mit

['en']

['wikipedia', 'bookcorpus']

['roberta-base', 'roberta-base-epoch_69']

# RoBERTa, Intermediate Checkpoint - Epoch 69 This model is part of our reimplementation of the [RoBERTa model](https://arxiv.org/abs/1907.11692), trained on Wikipedia and the Book Corpus only. We train this model for almost 100K steps, corresponding to 83 epochs. We provide the 84 checkpoints (including the randomly initialized weights before the training) to provide the ability to study the training dynamics of such models, and other possible use-cases. These models were trained in part of a work that studies how simple statistics from data, such as co-occurrences affects model predictions, which are described in the paper [Measuring Causal Effects of Data Statistics on Language Model's `Factual' Predictions](https://arxiv.org/abs/2207.14251). This is RoBERTa-base epoch_69. ## Model Description This model was captured during a reproduction of [RoBERTa-base](https://huggingface.co/roberta-base), for English: it is a Transformers model pretrained on a large corpus of English data, using the Masked Language Modelling (MLM). The intended uses, limitations, training data and training procedure for the fully trained model are similar to [RoBERTa-base](https://huggingface.co/roberta-base). Two major differences with the original model: * We trained our model for 100K steps, instead of 500K * We only use Wikipedia and the Book Corpus, as corpora which are publicly available. ### How to use Using code from [RoBERTa-base](https://huggingface.co/roberta-base), here is an example based on PyTorch: ``` from transformers import pipeline model = pipeline("fill-mask", model='yanaiela/roberta-base-epoch_83', device=-1, top_k=10) model("Hello, I'm the <mask> RoBERTa-base language model") ``` ## Citation info ```bibtex @article{2207.14251, Author = {Yanai Elazar and Nora Kassner and Shauli Ravfogel and Amir Feder and Abhilasha Ravichander and Marius Mosbach and Yonatan Belinkov and Hinrich Schütze and Yoav Goldberg}, Title = {Measuring Causal Effects of Data Statistics on Language Model's `Factual' Predictions}, Year = {2022}, Eprint = {arXiv:2207.14251}, } ```

4a0fe2a00a3cc71cbc560697dc698607

projecte-aina/mt-aina-en-ca

projecte-aina

cc-by-4.0

[]

## Aina Project's English-Catalan machine translation model ## Table of Contents - [Model Description](#model-description) - [Intended Uses and Limitations](#intended-use) - [How to Use](#how-to-use) - [Training](#training) - [Training data](#training-data) - [Training procedure](#training-procedure) - [Data Preparation](#data-preparation) - [Tokenization](#tokenization) - [Hyperparameters](#hyperparameters) - [Evaluation](#evaluation) - [Variable and Metrics](#variable-and-metrics) - [Evaluation Results](#evaluation-results) - [Additional Information](#additional-information) - [Author](#author) - [Contact Information](#contact-information) - [Copyright](#copyright) - [Licensing Information](#licensing-information) - [Funding](#funding) - [Disclaimer](#disclaimer) ## Model description This model was trained from scratch using the [Fairseq toolkit](https://fairseq.readthedocs.io/en/latest/) on a combination of English-Catalan datasets, up to 11 million sentences. Additionally, the model is evaluated on several public datasecomprising 5 different domains (general, adminstrative, technology, biomedical, and news). ## Intended uses and limitations You can use this model for machine translation from English to Catalan. ## How to use ### Usage Required libraries: ```bash pip install ctranslate2 pyonmttok ``` Translate a sentence using python ```python import ctranslate2 import pyonmttok from huggingface_hub import snapshot_download model_dir = snapshot_download(repo_id="projecte-aina/mt-aina-en-ca", revision="main") tokenizer=pyonmttok.Tokenizer(mode="none", sp_model_path = model_dir + "/spm.model") tokenized=tokenizer.tokenize("Welcome to the Aina Project!") translator = ctranslate2.Translator(model_dir) translated = translator.translate_batch([tokenized[0]]) print(tokenizer.detokenize(translated[0][0]['tokens'])) ``` ## Training ### Training data The model was trained on a combination of the following datasets: | Dataset | Sentences | |--------------------|----------------| | Global Voices | 21.342 | | Memories Lluires | 1.173.055 | | Wikimatrix | 1.205.908 | | TED Talks | 50.979 | | Tatoeba | 5.500 | | CoVost 2 ca-en | 79.633 | | CoVost 2 en-ca | 263.891 | | Europarl | 1.965.734 | | jw300 | 97.081 | | Crawled Generalitat| 38.595 | | Opus Books | 4.580 | | CC Aligned | 5.787.682 | | COVID_Wikipedia | 1.531 | | EuroBooks | 3.746 | | Gnome | 2.183 | | KDE 4 | 144.153 | | OpenSubtitles | 427.913 | | QED | 69.823 | | Ubuntu | 6.781 | | Wikimedia | 208.073 | |--------------------|----------------| | **Total** | **11.558.183** | ### Training procedure ### Data preparation All datasets are concatenated and filtered using the [mBERT Gencata parallel filter](https://huggingface.co/projecte-aina/mbert-base-gencata). Before training, the punctuation is normalized using a modified version of the join-single-file.py script from [SoftCatalà](https://github.com/Softcatala/nmt-models/blob/master/data-processing-tools/join-single-file.py) #### Tokenization All data is tokenized using sentencepiece, using 50 thousand token sentencepiece model learned from the combination of all filtered training data. This model is included. #### Hyperparameters The model is based on the Transformer-XLarge proposed by [Subramanian et al.](https://aclanthology.org/2021.wmt-1.18.pdf) The following hyperparamenters were set on the Fairseq toolkit: | Hyperparameter | Value | |------------------------------------|----------------------------------| | Architecture | transformer_vaswani_wmt_en_de_bi | | Embedding size | 1024 | | Feedforward size | 4096 | | Number of heads | 16 | | Encoder layers | 24 | | Decoder layers | 6 | | Normalize before attention | True | | --share-decoder-input-output-embed | True | | --share-all-embeddings | True | | Effective batch size | 96.000 | | Optimizer | adam | | Adam betas | (0.9, 0.980) | | Clip norm | 0.0 | | Learning rate | 1e-3 | | Lr. schedurer | inverse sqrt | | Warmup updates | 4000 | | Dropout | 0.1 | | Label smoothing | 0.1 | The model was trained for a total of 45.000 updates. Weights were saved every 1000 updates and reported results are the average of the last 32 checkpoints. ## Evaluation ### Variable and metrics We use the BLEU score for evaluation on test sets: [Flores-101](https://github.com/facebookresearch/flores), [TaCon](https://elrc-share.eu/repository/browse/tacon-spanish-constitution-mt-test-set/84a96138b98611ec9c1a00155d02670628f3e6857b0f422abd82abc3795ec8c2/), [United Nations](https://zenodo.org/record/3888414#.Y33-_tLMIW0), [Cybersecurity](https://elrc-share.eu/repository/browse/cyber-mt-test-set/2bd93faab98c11ec9c1a00155d026706b96a490ed3e140f0a29a80a08c46e91e/), [wmt19 biomedical test set](), [wmt13 news test set](https://elrc-share.eu/repository/browse/catalan-wmt2013-machine-translation-shared-task-test-set/84a96139b98611ec9c1a00155d0267061a0aa1b62e2248e89aab4952f3c230fc/) ### Evaluation results Below are the evaluation results on the machine translation from English to Catalan compared to [Softcatalà](https://www.softcatala.org/) and [Google Translate](https://translate.google.es/?hl=es): | Test set | SoftCatalà | Google Translate | mt-aina-en-ca | |----------------------|------------|------------------|---------------| | Spanish Constitution | 32,6 | 37,6 | **37,7** | | United Nations | 39,0 | 39,7 | **39,8** | | aina_aapp_ca-en | 46,5 | **51,5** | 48,8 | | european_comission | 49,1 | **52** | 49,5 | | Flores 101 dev | 41,0 | 41,6 | **42,9** | | Flores 101 devtest | 42,1 | 42,2 | **44,0** | | Cybersecurity | 42,5 | **46,5** | 45,8 | | wmt 19 biomedical | 21,7 | **25,2** | 25,1 | | wmt 13 news | 34,9 | 33,8 | **35,6** | | Average | 38,8 | **41,1** | 41,0 | ## Additional information ### Author Text Mining Unit (TeMU) at the Barcelona Supercomputing Center ([email protected]) ### Contact information For further information, send an email to [email protected] ### Copyright Copyright (c) 2022 Text Mining Unit at Barcelona Supercomputing Center ### Licensing Information [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0) ### Funding This work was funded by the [Departament de la Vicepresidència i de Polítiques Digitals i Territori de la Generalitat de Catalunya](https://politiquesdigitals.gencat.cat/ca/inici/index.html#googtrans(ca|en) within the framework of [Projecte AINA](https://politiquesdigitals.gencat.cat/ca/economia/catalonia-ai/aina). ## Disclaimer <details> <summary>Click to expand</summary> The models published in this repository are intended for a generalist purpose and are available to third parties. These models may have bias and/or any other undesirable distortions. When third parties, deploy or provide systems and/or services to other parties using any of these models (or using systems based on these models) or become users of the models, they should note that it is their responsibility to mitigate the risks arising from their use and, in any event, to comply with applicable regulations, including regulations regarding the use of Artificial Intelligence. In no event shall the owner and creator of the models (BSC – Barcelona Supercomputing Center) be liable for any results arising from the use made by third parties of these models.

c00058da64d3154b5ae406178924eaca

Helsinki-NLP/opus-mt-sv-mos

Helsinki-NLP

marian

transformers

translation

apache-2.0

['translation']

### opus-mt-sv-mos * source languages: sv * target languages: mos * OPUS readme: [sv-mos](https://github.com/Helsinki-NLP/OPUS-MT-train/blob/master/models/sv-mos/README.md) * dataset: opus * model: transformer-align * pre-processing: normalization + SentencePiece * download original weights: [opus-2020-01-16.zip](https://object.pouta.csc.fi/OPUS-MT-models/sv-mos/opus-2020-01-16.zip) * test set translations: [opus-2020-01-16.test.txt](https://object.pouta.csc.fi/OPUS-MT-models/sv-mos/opus-2020-01-16.test.txt) * test set scores: [opus-2020-01-16.eval.txt](https://object.pouta.csc.fi/OPUS-MT-models/sv-mos/opus-2020-01-16.eval.txt) ## Benchmarks | testset | BLEU | chr-F | |-----------------------|-------|-------| | JW300.sv.mos | 22.4 | 0.379 |

43b2b1761968671d22f82fab09dd2ed5

joey234/whisper-small-vi

joey234

whisper

transformers

automatic-speech-recognition

apache-2.0

['vi']

['mozilla-foundation/common_voice_11_0']

['whisper-event', 'generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # Whisper Small Vietnamese 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 vi dataset. It achieves the following results on the evaluation set: - Loss: 0.9921 - Wer: 34.2172 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 1e-05 - train_batch_size: 64 - eval_batch_size: 32 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - lr_scheduler_warmup_steps: 500 - training_steps: 5000 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | Wer | |:-------------:|:-----:|:----:|:---------------:|:-------:| | 0.0002 | 124.0 | 1000 | 0.7998 | 21.7706 | | 0.0001 | 249.0 | 2000 | 0.8833 | 28.9690 | | 0.0 | 374.0 | 3000 | 0.9382 | 30.8206 | | 0.0 | 499.0 | 4000 | 0.9754 | 34.4363 | | 0.0 | 624.0 | 5000 | 0.9921 | 34.2172 | ### Framework versions - Transformers 4.25.1 - Pytorch 1.13.0 - Datasets 2.7.1 - Tokenizers 0.13.2

48f84e65873df9efa4ae9927b20eb30e

qanastek/whisper-large-french-uncased

qanastek

whisper

transformers

automatic-speech-recognition

apache-2.0

['fr']

['mozilla-foundation/common_voice_11_0']

['whisper-event', 'generated_from_trainer', 'hf-asr-leaderboard']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # Whisper Large French This model is a fine-tuned version of [openai/whisper-large](https://huggingface.co/openai/whisper-large) on the mozilla-foundation/common_voice_11_0 fr dataset. It achieves the following results on the evaluation set: - Loss: 0.00 - Wer: 00.00 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 1e-05 - 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: 500 - training_steps: 5000 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | Wer | |:-------------:|:-----:|:----:|:---------------:|:-------:| | 0.00 | 0.2 | 1000 | 0.00 | 00.00 | ### Framework versions - Transformers 4.26.0.dev0 - Pytorch 1.11.0+cu102 - Datasets 2.7.1.dev0 - Tokenizers 0.13.2

f14b5761e15606a957ae0332eb91336e

alexjercan/codet5-base-buggy-error-description

alexjercan

t5

transformers

text2text-generation

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # codet5-base-buggy-error-description This model is a fine-tuned version of [Salesforce/codet5-base](https://huggingface.co/Salesforce/codet5-base) on an unknown dataset. ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - train_batch_size: 4 - eval_batch_size: 4 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - lr_scheduler_warmup_steps: 500 - num_epochs: 1 ### Framework versions - Transformers 4.16.2 - Pytorch 1.9.1 - Datasets 1.18.4 - Tokenizers 0.11.6

aa9c5535d99bba236370cceda837f19e

lct-rug-2022/edos-2023-baseline-distilbert-base-uncased-label_sexist

lct-rug-2022

distilbert

transformers

text-classification

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # edos-2023-baseline-distilbert-base-uncased-label_sexist 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: - Loss: 0.4852 - F1: 0.7874 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 1e-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 - lr_scheduler_warmup_steps: 5 - num_epochs: 8 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | F1 | |:-------------:|:-----:|:----:|:---------------:|:------:| | 0.4199 | 1.14 | 400 | 0.3911 | 0.7571 | | 0.293 | 2.29 | 800 | 0.3778 | 0.7899 | | 0.2348 | 3.43 | 1200 | 0.4102 | 0.7894 | | 0.1895 | 4.57 | 1600 | 0.4417 | 0.7835 | | 0.1392 | 5.71 | 2000 | 0.4852 | 0.7874 | ### Framework versions - Transformers 4.24.0 - Pytorch 1.12.1+cu113 - Datasets 2.7.1 - Tokenizers 0.13.2

060ab1672e994f920d3af913bfb5a3d5

JovialValley/model_syllable_onSet1

JovialValley

wav2vec2

transformers

automatic-speech-recognition

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # model_syllable_onSet1 This model is a fine-tuned version of [facebook/wav2vec2-large-xlsr-53](https://huggingface.co/facebook/wav2vec2-large-xlsr-53) on the None dataset. It achieves the following results on the evaluation set: - Loss: 0.1815 - 0 Precision: 1.0 - 0 Recall: 0.9677 - 0 F1-score: 0.9836 - 0 Support: 31 - 1 Precision: 0.9545 - 1 Recall: 1.0 - 1 F1-score: 0.9767 - 1 Support: 21 - 2 Precision: 1.0 - 2 Recall: 1.0 - 2 F1-score: 1.0 - 2 Support: 30 - 3 Precision: 1.0 - 3 Recall: 1.0 - 3 F1-score: 1.0 - 3 Support: 16 - Accuracy: 0.9898 - Macro avg Precision: 0.9886 - Macro avg Recall: 0.9919 - Macro avg F1-score: 0.9901 - Macro avg Support: 98 - Weighted avg Precision: 0.9903 - Weighted avg Recall: 0.9898 - Weighted avg F1-score: 0.9898 - Weighted avg Support: 98 - Wer: 0.7883 - Mtrix: [[0, 1, 2, 3], [0, 30, 1, 0, 0], [1, 0, 21, 0, 0], [2, 0, 0, 30, 0], [3, 0, 0, 0, 16]] ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 0.0003 - train_batch_size: 8 - eval_batch_size: 8 - seed: 42 - gradient_accumulation_steps: 2 - 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: 200 - num_epochs: 70 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | 0 Precision | 0 Recall | 0 F1-score | 0 Support | 1 Precision | 1 Recall | 1 F1-score | 1 Support | 2 Precision | 2 Recall | 2 F1-score | 2 Support | 3 Precision | 3 Recall | 3 F1-score | 3 Support | Accuracy | Macro avg Precision | Macro avg Recall | Macro avg F1-score | Macro avg Support | Weighted avg Precision | Weighted avg Recall | Weighted avg F1-score | Weighted avg Support | Wer | Mtrix | |:-------------:|:-----:|:----:|:---------------:|:-----------:|:--------:|:----------:|:---------:|:-----------:|:--------:|:----------:|:---------:|:-----------:|:--------:|:----------:|:---------:|:-----------:|:--------:|:----------:|:---------:|:--------:|:-------------------:|:----------------:|:------------------:|:-----------------:|:----------------------:|:-------------------:|:---------------------:|:--------------------:|:------:|:--------------------------------------------------------------------------------------:| | 1.6949 | 4.16 | 100 | 1.6177 | 1.0 | 0.2581 | 0.4103 | 31 | 0.0 | 0.0 | 0.0 | 21 | 0.3333 | 1.0 | 0.5 | 30 | 0.0 | 0.0 | 0.0 | 16 | 0.3878 | 0.3333 | 0.3145 | 0.2276 | 98 | 0.4184 | 0.3878 | 0.2828 | 98 | 0.9655 | [[0, 1, 2, 3], [0, 8, 0, 23, 0], [1, 0, 0, 21, 0], [2, 0, 0, 30, 0], [3, 0, 0, 16, 0]] | | 1.5778 | 8.33 | 200 | 1.3535 | 1.0 | 0.2581 | 0.4103 | 31 | 0.0 | 0.0 | 0.0 | 21 | 0.3333 | 1.0 | 0.5 | 30 | 0.0 | 0.0 | 0.0 | 16 | 0.3878 | 0.3333 | 0.3145 | 0.2276 | 98 | 0.4184 | 0.3878 | 0.2828 | 98 | 0.9655 | [[0, 1, 2, 3], [0, 8, 0, 23, 0], [1, 0, 0, 21, 0], [2, 0, 0, 30, 0], [3, 0, 0, 16, 0]] | | 1.2861 | 12.49 | 300 | 1.0938 | 1.0 | 0.2581 | 0.4103 | 31 | 0.0 | 0.0 | 0.0 | 21 | 0.3333 | 1.0 | 0.5 | 30 | 0.0 | 0.0 | 0.0 | 16 | 0.3878 | 0.3333 | 0.3145 | 0.2276 | 98 | 0.4184 | 0.3878 | 0.2828 | 98 | 0.9655 | [[0, 1, 2, 3], [0, 8, 0, 23, 0], [1, 0, 0, 21, 0], [2, 0, 0, 30, 0], [3, 0, 0, 16, 0]] | | 0.954 | 16.65 | 400 | 0.9480 | 1.0 | 0.2581 | 0.4103 | 31 | 0.0 | 0.0 | 0.0 | 21 | 0.3333 | 1.0 | 0.5 | 30 | 0.0 | 0.0 | 0.0 | 16 | 0.3878 | 0.3333 | 0.3145 | 0.2276 | 98 | 0.4184 | 0.3878 | 0.2828 | 98 | 0.9655 | [[0, 1, 2, 3], [0, 8, 0, 23, 0], [1, 0, 0, 21, 0], [2, 0, 0, 30, 0], [3, 0, 0, 16, 0]] | | 0.8849 | 20.82 | 500 | 0.9231 | 1.0 | 0.2581 | 0.4103 | 31 | 0.0 | 0.0 | 0.0 | 21 | 0.3333 | 1.0 | 0.5 | 30 | 0.0 | 0.0 | 0.0 | 16 | 0.3878 | 0.3333 | 0.3145 | 0.2276 | 98 | 0.4184 | 0.3878 | 0.2828 | 98 | 0.9655 | [[0, 1, 2, 3], [0, 8, 0, 23, 0], [1, 0, 0, 21, 0], [2, 0, 0, 30, 0], [3, 0, 0, 16, 0]] | | 0.8674 | 24.98 | 600 | 0.8767 | 1.0 | 0.2581 | 0.4103 | 31 | 0.0 | 0.0 | 0.0 | 21 | 0.3333 | 1.0 | 0.5 | 30 | 0.0 | 0.0 | 0.0 | 16 | 0.3878 | 0.3333 | 0.3145 | 0.2276 | 98 | 0.4184 | 0.3878 | 0.2828 | 98 | 0.9655 | [[0, 1, 2, 3], [0, 8, 0, 23, 0], [1, 0, 0, 21, 0], [2, 0, 0, 30, 0], [3, 0, 0, 16, 0]] | | 0.7921 | 29.16 | 700 | 0.7519 | 1.0 | 0.9677 | 0.9836 | 31 | 0.9545 | 1.0 | 0.9767 | 21 | 1.0 | 1.0 | 1.0 | 30 | 1.0 | 1.0 | 1.0 | 16 | 0.9898 | 0.9886 | 0.9919 | 0.9901 | 98 | 0.9903 | 0.9898 | 0.9898 | 98 | 1.0 | [[0, 1, 2, 3], [0, 30, 1, 0, 0], [1, 0, 21, 0, 0], [2, 0, 0, 30, 0], [3, 0, 0, 0, 16]] | | 0.7851 | 33.33 | 800 | 0.8212 | 1.0 | 0.9032 | 0.9492 | 31 | 0.84 | 1.0 | 0.9130 | 21 | 1.0 | 1.0 | 1.0 | 30 | 1.0 | 0.9375 | 0.9677 | 16 | 0.9592 | 0.96 | 0.9602 | 0.9575 | 98 | 0.9657 | 0.9592 | 0.9600 | 98 | 1.0 | [[0, 1, 2, 3], [0, 28, 3, 0, 0], [1, 0, 21, 0, 0], [2, 0, 0, 30, 0], [3, 0, 1, 0, 15]] | | 0.7657 | 37.49 | 900 | 0.7504 | 1.0 | 0.9677 | 0.9836 | 31 | 0.9130 | 1.0 | 0.9545 | 21 | 1.0 | 1.0 | 1.0 | 30 | 1.0 | 0.9375 | 0.9677 | 16 | 0.9796 | 0.9783 | 0.9763 | 0.9765 | 98 | 0.9814 | 0.9796 | 0.9798 | 98 | 1.0 | [[0, 1, 2, 3], [0, 30, 1, 0, 0], [1, 0, 21, 0, 0], [2, 0, 0, 30, 0], [3, 0, 1, 0, 15]] | | 0.688 | 41.65 | 1000 | 0.6897 | 1.0 | 1.0 | 1.0 | 31 | 0.9130 | 1.0 | 0.9545 | 21 | 1.0 | 0.9667 | 0.9831 | 30 | 1.0 | 0.9375 | 0.9677 | 16 | 0.9796 | 0.9783 | 0.9760 | 0.9763 | 98 | 0.9814 | 0.9796 | 0.9798 | 98 | 0.7008 | [[0, 1, 2, 3], [0, 31, 0, 0, 0], [1, 0, 21, 0, 0], [2, 0, 1, 29, 0], [3, 0, 1, 0, 15]] | | 0.4415 | 45.82 | 1100 | 0.1917 | 1.0 | 1.0 | 1.0 | 31 | 1.0 | 1.0 | 1.0 | 21 | 1.0 | 1.0 | 1.0 | 30 | 1.0 | 1.0 | 1.0 | 16 | 1.0 | 1.0 | 1.0 | 1.0 | 98 | 1.0 | 1.0 | 1.0 | 98 | 0.6974 | [[0, 1, 2, 3], [0, 31, 0, 0, 0], [1, 0, 21, 0, 0], [2, 0, 0, 30, 0], [3, 0, 0, 0, 16]] | | 0.3074 | 49.98 | 1200 | 0.1865 | 1.0 | 0.9677 | 0.9836 | 31 | 0.9545 | 1.0 | 0.9767 | 21 | 1.0 | 1.0 | 1.0 | 30 | 1.0 | 1.0 | 1.0 | 16 | 0.9898 | 0.9886 | 0.9919 | 0.9901 | 98 | 0.9903 | 0.9898 | 0.9898 | 98 | 0.6686 | [[0, 1, 2, 3], [0, 30, 1, 0, 0], [1, 0, 21, 0, 0], [2, 0, 0, 30, 0], [3, 0, 0, 0, 16]] | | 0.2069 | 54.16 | 1300 | 0.1821 | 1.0 | 0.9677 | 0.9836 | 31 | 0.9545 | 1.0 | 0.9767 | 21 | 1.0 | 1.0 | 1.0 | 30 | 1.0 | 1.0 | 1.0 | 16 | 0.9898 | 0.9886 | 0.9919 | 0.9901 | 98 | 0.9903 | 0.9898 | 0.9898 | 98 | 0.7043 | [[0, 1, 2, 3], [0, 30, 1, 0, 0], [1, 0, 21, 0, 0], [2, 0, 0, 30, 0], [3, 0, 0, 0, 16]] | | 0.1791 | 58.33 | 1400 | 0.1866 | 1.0 | 0.9677 | 0.9836 | 31 | 0.9130 | 1.0 | 0.9545 | 21 | 1.0 | 0.9667 | 0.9831 | 30 | 1.0 | 1.0 | 1.0 | 16 | 0.9796 | 0.9783 | 0.9836 | 0.9803 | 98 | 0.9814 | 0.9796 | 0.9799 | 98 | 0.6893 | [[0, 1, 2, 3], [0, 30, 1, 0, 0], [1, 0, 21, 0, 0], [2, 0, 1, 29, 0], [3, 0, 0, 0, 16]] | | 0.1717 | 62.49 | 1500 | 0.1839 | 1.0 | 0.9677 | 0.9836 | 31 | 0.9545 | 1.0 | 0.9767 | 21 | 1.0 | 1.0 | 1.0 | 30 | 1.0 | 1.0 | 1.0 | 16 | 0.9898 | 0.9886 | 0.9919 | 0.9901 | 98 | 0.9903 | 0.9898 | 0.9898 | 98 | 0.7848 | [[0, 1, 2, 3], [0, 30, 1, 0, 0], [1, 0, 21, 0, 0], [2, 0, 0, 30, 0], [3, 0, 0, 0, 16]] | | 0.1571 | 66.65 | 1600 | 0.1799 | 1.0 | 0.9677 | 0.9836 | 31 | 0.9545 | 1.0 | 0.9767 | 21 | 1.0 | 1.0 | 1.0 | 30 | 1.0 | 1.0 | 1.0 | 16 | 0.9898 | 0.9886 | 0.9919 | 0.9901 | 98 | 0.9903 | 0.9898 | 0.9898 | 98 | 0.7929 | [[0, 1, 2, 3], [0, 30, 1, 0, 0], [1, 0, 21, 0, 0], [2, 0, 0, 30, 0], [3, 0, 0, 0, 16]] | ### Framework versions - Transformers 4.25.1 - Pytorch 1.13.0+cu116 - Datasets 2.8.0 - Tokenizers 0.13.2

74b22347f41a4e124dd113a44611d4fe

arampacha/whisper-large-uk

arampacha

whisper

transformers

automatic-speech-recognition

apache-2.0

['uk']

['mozilla-foundation/common_voice_11_0', 'google/fleurs']

['whisper-event', 'generated_from_trainer']

# whisper-base-uk This model is a fine-tuned version of [openai/whisper-large-v2](https://huggingface.co/openai/whisper-large-v2) on the Common Voice 11.0 dataset. It achieves the following results on the evaluation set: - eval_loss: 1.3201 - eval_wer: 10.2869 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 1e-05 - 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 - lr_scheduler_warmup_steps: 500 - training_steps: 5000 - mixed_precision_training: Native AMP ### Framework versions - Transformers 4.26.0.dev0 - Pytorch 1.13.0+cu116 - Datasets 2.7.1.dev0 - Tokenizers 0.13.2

ab69e623d71ab9b9903e7079b2244bdc

jonatasgrosman/exp_w2v2r_en_xls-r_accent_us-5_england-5_s334

jonatasgrosman

wav2vec2

transformers

automatic-speech-recognition

apache-2.0

['en']

['mozilla-foundation/common_voice_7_0']

['automatic-speech-recognition', 'en']

# exp_w2v2r_en_xls-r_accent_us-5_england-5_s334 Fine-tuned [facebook/wav2vec2-xls-r-300m](https://huggingface.co/facebook/wav2vec2-xls-r-300m) for speech recognition using the train split of [Common Voice 7.0 (en)](https://huggingface.co/datasets/mozilla-foundation/common_voice_7_0). When using this model, make sure that your speech input is sampled at 16kHz. This model has been fine-tuned by the [HuggingSound](https://github.com/jonatasgrosman/huggingsound) tool.

e50e85324282c1ee7dc346d1d93bae19

TheNateTCY/fulltrain_optmodel

TheNateTCY

opt

transformers

text-generation

other

['generated_from_keras_callback']

<!-- This model card has been generated automatically according to the information Keras had access to. You should probably proofread and complete it, then remove this comment. --> # TheNateTCY/fulltrain_optmodel This model is a fine-tuned version of [facebook/opt-125m](https://huggingface.co/facebook/opt-125m) on an unknown dataset. It achieves the following results on the evaluation set: - Train Loss: 1.8560 - Validation Loss: 1.2171 - Epoch: 0 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - optimizer: {'name': 'AdamWeightDecay', 'learning_rate': {'class_name': 'WarmUp', 'config': {'initial_learning_rate': 5e-05, 'decay_schedule_fn': {'class_name': 'PolynomialDecay', 'config': {'initial_learning_rate': 5e-05, 'decay_steps': 8375, '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: float32 ### Training results | Train Loss | Validation Loss | Epoch | |:----------:|:---------------:|:-----:| | 1.8560 | 1.2171 | 0 | ### Framework versions - Transformers 4.25.1 - TensorFlow 2.10.1 - Datasets 2.7.1 - Tokenizers 0.13.2

3be524e9197c1900fc86c15cc8c37ee3

ieborhan/irisg444_4c0-Species-classification

ieborhan

sklearn

tabular-classification

apache-2.0

['tabular-classification', 'baseline-trainer']

## Baseline Model trained on irisg444_4c0 to apply classification on Species **Metrics of the best model:** accuracy 0.953333 recall_macro 0.953333 precision_macro 0.956229 f1_macro 0.953216 Name: LogisticRegression(class_weight='balanced', max_iter=1000), dtype: float64 **See model plot below:** <style>#sk-container-id-2 {color: black;background-color: white;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: "▸";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: "▾";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: "";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: "";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: "";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id="sk-container-id-2" class="sk-top-container"><div class="sk-text-repr-fallback"><pre>Pipeline(steps=[(&#x27;easypreprocessor&#x27;,EasyPreprocessor(types= continuous dirty_float ... free_string useless SepalLengthCm True False ... False False SepalWidthCm True False ... False False PetalLengthCm True False ... False False PetalWidthCm True False ... False False[4 rows x 7 columns])),(&#x27;logisticregression&#x27;,LogisticRegression(C=1, class_weight=&#x27;balanced&#x27;,max_iter=1000))])</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class="sk-container" hidden><div class="sk-item sk-dashed-wrapped"><div class="sk-label-container"><div class="sk-label sk-toggleable"><input class="sk-toggleable__control sk-hidden--visually" id="sk-estimator-id-4" type="checkbox" ><label for="sk-estimator-id-4" class="sk-toggleable__label sk-toggleable__label-arrow">Pipeline</label><div class="sk-toggleable__content"><pre>Pipeline(steps=[(&#x27;easypreprocessor&#x27;,EasyPreprocessor(types= continuous dirty_float ... free_string useless SepalLengthCm True False ... False False SepalWidthCm True False ... False False PetalLengthCm True False ... False False PetalWidthCm True False ... False False[4 rows x 7 columns])),(&#x27;logisticregression&#x27;,LogisticRegression(C=1, class_weight=&#x27;balanced&#x27;,max_iter=1000))])</pre></div></div></div><div class="sk-serial"><div class="sk-item"><div class="sk-estimator sk-toggleable"><input class="sk-toggleable__control sk-hidden--visually" id="sk-estimator-id-5" type="checkbox" ><label for="sk-estimator-id-5" class="sk-toggleable__label sk-toggleable__label-arrow">EasyPreprocessor</label><div class="sk-toggleable__content"><pre>EasyPreprocessor(types= continuous dirty_float ... free_string useless SepalLengthCm True False ... False False SepalWidthCm True False ... False False PetalLengthCm True False ... False False PetalWidthCm True False ... False False[4 rows x 7 columns])</pre></div></div></div><div class="sk-item"><div class="sk-estimator sk-toggleable"><input class="sk-toggleable__control sk-hidden--visually" id="sk-estimator-id-6" type="checkbox" ><label for="sk-estimator-id-6" class="sk-toggleable__label sk-toggleable__label-arrow">LogisticRegression</label><div class="sk-toggleable__content"><pre>LogisticRegression(C=1, class_weight=&#x27;balanced&#x27;, max_iter=1000)</pre></div></div></div></div></div></div></div> **Disclaimer:** This model is trained with dabl library as a baseline, for better results, use [AutoTrain](https://huggingface.co/autotrain). **Logs of training** including the models tried in the process can be found in logs.txt

ec8f759a2cbcd3838ac5a9ae0eee5a5b

Helsinki-NLP/opus-mt-fr-bi

Helsinki-NLP

marian

transformers

translation

apache-2.0

['translation']

### opus-mt-fr-bi * source languages: fr * target languages: bi * OPUS readme: [fr-bi](https://github.com/Helsinki-NLP/OPUS-MT-train/blob/master/models/fr-bi/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/fr-bi/opus-2020-01-20.zip) * test set translations: [opus-2020-01-20.test.txt](https://object.pouta.csc.fi/OPUS-MT-models/fr-bi/opus-2020-01-20.test.txt) * test set scores: [opus-2020-01-20.eval.txt](https://object.pouta.csc.fi/OPUS-MT-models/fr-bi/opus-2020-01-20.eval.txt) ## Benchmarks | testset | BLEU | chr-F | |-----------------------|-------|-------| | JW300.fr.bi | 28.4 | 0.464 |

5649db29ae0810704144daf9ba068e0f

SetFit/distilbert-base-uncased__hate_speech_offensive__train-32-4

SetFit

distilbert

transformers

text-classification

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # distilbert-base-uncased__hate_speech_offensive__train-32-4 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: - Loss: 0.7384 - Accuracy: 0.724 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-05 - train_batch_size: 4 - eval_batch_size: 4 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 50 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | Accuracy | |:-------------:|:-----:|:----:|:---------------:|:--------:| | 1.1013 | 1.0 | 19 | 1.0733 | 0.55 | | 1.0226 | 2.0 | 38 | 1.0064 | 0.65 | | 0.8539 | 3.0 | 57 | 0.8758 | 0.75 | | 0.584 | 4.0 | 76 | 0.6941 | 0.7 | | 0.2813 | 5.0 | 95 | 0.5151 | 0.7 | | 0.1122 | 6.0 | 114 | 0.4351 | 0.8 | | 0.0432 | 7.0 | 133 | 0.4896 | 0.85 | | 0.0199 | 8.0 | 152 | 0.5391 | 0.85 | | 0.0126 | 9.0 | 171 | 0.5200 | 0.85 | | 0.0085 | 10.0 | 190 | 0.5622 | 0.85 | | 0.0069 | 11.0 | 209 | 0.5950 | 0.85 | | 0.0058 | 12.0 | 228 | 0.6015 | 0.85 | | 0.0053 | 13.0 | 247 | 0.6120 | 0.85 | | 0.0042 | 14.0 | 266 | 0.6347 | 0.85 | | 0.0039 | 15.0 | 285 | 0.6453 | 0.85 | | 0.0034 | 16.0 | 304 | 0.6660 | 0.85 | ### Framework versions - Transformers 4.15.0 - Pytorch 1.10.2+cu102 - Datasets 1.18.2 - Tokenizers 0.10.3

5f378270188a2cd951033abe2aa32a85

jonatasgrosman/exp_w2v2t_es_no-pretraining_s807

jonatasgrosman

wav2vec2

transformers

automatic-speech-recognition

apache-2.0

['es']

['mozilla-foundation/common_voice_7_0']

['automatic-speech-recognition', 'es']

# exp_w2v2t_es_no-pretraining_s807 Fine-tuned randomly initialized wav2vec2 model for speech recognition using the train split of [Common Voice 7.0 (es)](https://huggingface.co/datasets/mozilla-foundation/common_voice_7_0). When using this model, make sure that your speech input is sampled at 16kHz. This model has been fine-tuned by the [HuggingSound](https://github.com/jonatasgrosman/huggingsound) tool.

1608e6c97878c5322a3d7e3d3d806c08

MEDT/ChatBot

MEDT

gpt2

transformers

conversational

mit

['conversational']

# DialoGPT Trained on the Speech of a Game Character This is an instance of [microsoft/DialoGPT-medium](https://huggingface.co/microsoft/DialoGPT-medium) trained on a game character, Joshua from [The World Ends With You](https://en.wikipedia.org/wiki/The_World_Ends_with_You). The data comes from [a Kaggle game script dataset](https://www.kaggle.com/ruolinzheng/twewy-game-script). I built a Discord AI chatbot based on this model. [Check out my GitHub repo.](https://github.com/RuolinZheng08/twewy-discord-chatbot) Chat with the model: ```python from transformers import AutoTokenizer, AutoModelWithLMHead tokenizer = AutoTokenizer.from_pretrained("r3dhummingbird/DialoGPT-medium-joshua") model = AutoModelWithLMHead.from_pretrained("r3dhummingbird/DialoGPT-medium-joshua") # Let's chat for 100 lines for step in range(100): # encode the new user input, add the eos_token and return a tensor in Pytorch new_user_input_ids = tokenizer.encode(input(">> User:") + tokenizer.eos_token, return_tensors='pt') # print(new_user_input_ids) # append the new user input tokens to the chat history bot_input_ids = torch.cat([chat_history_ids, new_user_input_ids], dim=-1) if step > 0 else new_user_input_ids # generated a response while limiting the total chat history to 1000 tokens, chat_history_ids = model.generate( bot_input_ids, max_length=200, pad_token_id=tokenizer.eos_token_id, no_repeat_ngram_size=3, do_sample=True, top_k=100, top_p=0.7, temperature=0.8 ) # pretty print last ouput tokens from bot print("JoshuaBot: {}".format(tokenizer.decode(chat_history_ids[:, bot_input_ids.shape[-1]:][0], skip_special_tokens=True))) ```

a2d65dd0fa0e00364c69ac839da931ff

k3lana/xlm-roberta-base-finetuned-panx-de-fr

k3lana

xlm-roberta

transformers

token-classification

mit

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # xlm-roberta-base-finetuned-panx-de-fr 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.1608 - F1: 0.8593 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - train_batch_size: 24 - eval_batch_size: 24 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 3 ### Training results | Training Loss | Epoch | Step | Validation Loss | F1 | |:-------------:|:-----:|:----:|:---------------:|:------:| | 0.2888 | 1.0 | 715 | 0.1779 | 0.8233 | | 0.1437 | 2.0 | 1430 | 0.1570 | 0.8497 | | 0.0931 | 3.0 | 2145 | 0.1608 | 0.8593 | ### Framework versions - Transformers 4.11.3 - Pytorch 1.12.1+cu113 - Datasets 1.16.1 - Tokenizers 0.10.3

cf47ea12a762581cc79bd9c003e3e485

csam/finetuning-sentiment-model-3000-samples

csam

distilbert

transformers

text-classification

apache-2.0

['imdb']

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # finetuning-sentiment-model-3000-samples 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.2913 - Accuracy: 0.88 - F1: 0.8808 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-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: 2 ### Training results ### Framework versions - Transformers 4.23.1 - Pytorch 1.12.1+cu113 - Datasets 2.5.2 - Tokenizers 0.13.1

e5b4c5ee4a3ad64138b404e64d7135cb

gchhablani/bert-base-cased-finetuned-stsb

gchhablani

bert

transformers

text-classification

apache-2.0

['en']

['glue']

['generated_from_trainer', 'fnet-bert-base-comparison']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # bert-base-cased-finetuned-stsb This model is a fine-tuned version of [bert-base-cased](https://huggingface.co/bert-base-cased) on the GLUE STSB dataset. It achieves the following results on the evaluation set: - Loss: 0.4861 - Pearson: 0.8926 - Spearmanr: 0.8898 - Combined Score: 0.8912 The model was fine-tuned to compare [google/fnet-base](https://huggingface.co/google/fnet-base) as introduced in [this paper](https://arxiv.org/abs/2105.03824) against [bert-base-cased](https://huggingface.co/bert-base-cased). ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure This model is trained using the [run_glue](https://github.com/huggingface/transformers/blob/master/examples/pytorch/text-classification/run_glue.py) script. The following command was used: ```bash #!/usr/bin/bash python ../run_glue.py \\n --model_name_or_path bert-base-cased \\n --task_name stsb \\n --do_train \\n --do_eval \\n --max_seq_length 512 \\n --per_device_train_batch_size 16 \\n --learning_rate 2e-5 \\n --num_train_epochs 3 \\n --output_dir bert-base-cased-finetuned-stsb \\n --push_to_hub \\n --hub_strategy all_checkpoints \\n --logging_strategy epoch \\n --save_strategy epoch \\n --evaluation_strategy epoch \\n``` ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-05 - 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: 3.0 ### Training results | Training Loss | Epoch | Step | Combined Score | Validation Loss | Pearson | Spearmanr | |:-------------:|:-----:|:----:|:--------------:|:---------------:|:-------:|:---------:| | 1.1174 | 1.0 | 360 | 0.8816 | 0.5000 | 0.8832 | 0.8800 | | 0.3835 | 2.0 | 720 | 0.8901 | 0.4672 | 0.8915 | 0.8888 | | 0.2388 | 3.0 | 1080 | 0.8912 | 0.4861 | 0.8926 | 0.8898 | ### Framework versions - Transformers 4.11.0.dev0 - Pytorch 1.9.0 - Datasets 1.12.1 - Tokenizers 0.10.3

82422fc3000b327511490fcfb35bf262

Helsinki-NLP/opus-mt-tc-big-es-zle

Helsinki-NLP

marian

transformers

translation

cc-by-4.0

['be', 'es', 'ru', 'uk', 'zle']

['translation', 'opus-mt-tc']

# opus-mt-tc-big-es-zle Neural machine translation model for translating from Spanish (es) to East Slavic languages (zle). This model is part of the [OPUS-MT project](https://github.com/Helsinki-NLP/Opus-MT), an effort to make neural machine translation models widely available and accessible for many languages in the world. All models are originally trained using the amazing framework of [Marian NMT](https://marian-nmt.github.io/), an efficient NMT implementation written in pure C++. The models have been converted to pyTorch using the transformers library by huggingface. Training data is taken from [OPUS](https://opus.nlpl.eu/) and training pipelines use the procedures of [OPUS-MT-train](https://github.com/Helsinki-NLP/Opus-MT-train). * Publications: [OPUS-MT – Building open translation services for the World](https://aclanthology.org/2020.eamt-1.61/) and [The Tatoeba Translation Challenge – Realistic Data Sets for Low Resource and Multilingual MT](https://aclanthology.org/2020.wmt-1.139/) (Please, cite if you use this model.) ``` @inproceedings{tiedemann-thottingal-2020-opus, title = "{OPUS}-{MT} {--} Building open translation services for the World", author = {Tiedemann, J{\"o}rg and Thottingal, Santhosh}, booktitle = "Proceedings of the 22nd Annual Conference of the European Association for Machine Translation", month = nov, year = "2020", address = "Lisboa, Portugal", publisher = "European Association for Machine Translation", url = "https://aclanthology.org/2020.eamt-1.61", pages = "479--480", } @inproceedings{tiedemann-2020-tatoeba, title = "The Tatoeba Translation Challenge {--} Realistic Data Sets for Low Resource and Multilingual {MT}", author = {Tiedemann, J{\"o}rg}, booktitle = "Proceedings of the Fifth Conference on Machine Translation", month = nov, year = "2020", address = "Online", publisher = "Association for Computational Linguistics", url = "https://aclanthology.org/2020.wmt-1.139", pages = "1174--1182", } ``` ## Model info * Release: 2022-03-23 * source language(s): spa * target language(s): bel rus ukr * valid target language labels: >>bel<< >>rus<< >>ukr<< * model: transformer-big * data: opusTCv20210807 ([source](https://github.com/Helsinki-NLP/Tatoeba-Challenge)) * tokenization: SentencePiece (spm32k,spm32k) * original model: [opusTCv20210807_transformer-big_2022-03-23.zip](https://object.pouta.csc.fi/Tatoeba-MT-models/spa-zle/opusTCv20210807_transformer-big_2022-03-23.zip) * more information released models: [OPUS-MT spa-zle README](https://github.com/Helsinki-NLP/Tatoeba-Challenge/tree/master/models/spa-zle/README.md) * more information about the model: [MarianMT](https://huggingface.co/docs/transformers/model_doc/marian) This is a multilingual translation model with multiple target languages. A sentence initial language token is required in the form of `>>id<<` (id = valid target language ID), e.g. `>>bel<<` ## Usage A short example code: ```python from transformers import MarianMTModel, MarianTokenizer src_text = [ ">>rus<< Su novela se vendió bien.", ">>ukr<< Quiero ir a Corea del Norte." ] model_name = "pytorch-models/opus-mt-tc-big-es-zle" tokenizer = MarianTokenizer.from_pretrained(model_name) model = MarianMTModel.from_pretrained(model_name) translated = model.generate(**tokenizer(src_text, return_tensors="pt", padding=True)) for t in translated: print( tokenizer.decode(t, skip_special_tokens=True) ) # expected output: # Его роман хорошо продавался. # Я хочу поїхати до Північної Кореї. ``` You can also use OPUS-MT models with the transformers pipelines, for example: ```python from transformers import pipeline pipe = pipeline("translation", model="Helsinki-NLP/opus-mt-tc-big-es-zle") print(pipe(">>rus<< Su novela se vendió bien.")) # expected output: Его роман хорошо продавался. ``` ## Benchmarks * test set translations: [opusTCv20210807_transformer-big_2022-03-23.test.txt](https://object.pouta.csc.fi/Tatoeba-MT-models/spa-zle/opusTCv20210807_transformer-big_2022-03-23.test.txt) * test set scores: [opusTCv20210807_transformer-big_2022-03-23.eval.txt](https://object.pouta.csc.fi/Tatoeba-MT-models/spa-zle/opusTCv20210807_transformer-big_2022-03-23.eval.txt) * benchmark results: [benchmark_results.txt](benchmark_results.txt) * benchmark output: [benchmark_translations.zip](benchmark_translations.zip) | langpair | testset | chr-F | BLEU | #sent | #words | |----------|---------|-------|-------|-------|--------| | spa-bel | tatoeba-test-v2021-08-07 | 0.54506 | 27.5 | 205 | 1259 | | spa-rus | tatoeba-test-v2021-08-07 | 0.68523 | 49.0 | 10506 | 69242 | | spa-ukr | tatoeba-test-v2021-08-07 | 0.63502 | 42.3 | 10115 | 54544 | | spa-rus | flores101-devtest | 0.49913 | 20.2 | 1012 | 23295 | | spa-ukr | flores101-devtest | 0.47772 | 17.4 | 1012 | 22810 | | spa-rus | newstest2012 | 0.52436 | 24.6 | 3003 | 64790 | | spa-rus | newstest2013 | 0.54249 | 26.9 | 3000 | 58560 | ## Acknowledgements The work is supported by the [European Language Grid](https://www.european-language-grid.eu/) as [pilot project 2866](https://live.european-language-grid.eu/catalogue/#/resource/projects/2866), by the [FoTran project](https://www.helsinki.fi/en/researchgroups/natural-language-understanding-with-cross-lingual-grounding), funded by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 771113), and the [MeMAD project](https://memad.eu/), funded by the European Union’s Horizon 2020 Research and Innovation Programme under grant agreement No 780069. We are also grateful for the generous computational resources and IT infrastructure provided by [CSC -- IT Center for Science](https://www.csc.fi/), Finland. ## Model conversion info * transformers version: 4.16.2 * OPUS-MT git hash: 1bdabf7 * port time: Thu Mar 24 03:35:13 EET 2022 * port machine: LM0-400-22516.local

26ea00e38fd0841a9c2ea4611b0ed9b6

gostrive/distilbert-base-uncased-finetuned-squad-d5716d28

gostrive

distilbert

transformers

question-answering

apache-2.0

['en']

['squad']

['question-answering']

# DistilBERT with a second step of distillation ## Model description This model replicates the "DistilBERT (D)" model from Table 2 of the [DistilBERT paper](https://arxiv.org/pdf/1910.01108.pdf). In this approach, a DistilBERT student is fine-tuned on SQuAD v1.1, but with a BERT model (also fine-tuned on SQuAD v1.1) acting as a teacher for a second step of task-specific distillation. In this version, the following pre-trained models were used: * Student: `distilbert-base-uncased` * Teacher: `lewtun/bert-base-uncased-finetuned-squad-v1` ## Training data This model was trained on the SQuAD v1.1 dataset which can be obtained from the `datasets` library as follows: ```python from datasets import load_dataset squad = load_dataset('squad') ``` ## Training procedure ## Eval results | | Exact Match | F1 | |------------------|-------------|------| | DistilBERT paper | 79.1 | 86.9 | | Ours | 78.4 | 86.5 | The scores were calculated using the `squad` metric from `datasets`. ### BibTeX entry and citation info ```bibtex @misc{sanh2020distilbert, title={DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter}, author={Victor Sanh and Lysandre Debut and Julien Chaumond and Thomas Wolf}, year={2020}, eprint={1910.01108}, archivePrefix={arXiv}, primaryClass={cs.CL} } ```

206913b81dd6917c52eb8c6176e2b1eb

Evelyn18/distilbert-base-uncased-becasv3-1

Evelyn18

distilbert

transformers

question-answering

apache-2.0

['becasv3']

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # distilbert-base-uncased-becasv3-1 This model is a fine-tuned version of [distilbert-base-uncased](https://huggingface.co/distilbert-base-uncased) on the becasv3 dataset. It achieves the following results on the evaluation set: - Loss: 3.1086 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-05 - train_batch_size: 10 - eval_batch_size: 10 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 8 ### Training results | Training Loss | Epoch | Step | Validation Loss | |:-------------:|:-----:|:----:|:---------------:| | No log | 1.0 | 8 | 5.1063 | | No log | 2.0 | 16 | 4.4615 | | No log | 3.0 | 24 | 3.9351 | | No log | 4.0 | 32 | 3.5490 | | No log | 5.0 | 40 | 3.3299 | | No log | 6.0 | 48 | 3.2148 | | No log | 7.0 | 56 | 3.1292 | | No log | 8.0 | 64 | 3.1086 | ### Framework versions - Transformers 4.20.1 - Pytorch 1.12.0+cu113 - Datasets 2.3.2 - Tokenizers 0.12.1

8c273b223c303663038329160bf83339

Sandeepanie/clinical-finetuned-AgitationModel

Sandeepanie

bert

transformers

text-classification

mit

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # clinical-finetuned-AgitationModel This model is a fine-tuned version of [emilyalsentzer/Bio_ClinicalBERT](https://huggingface.co/emilyalsentzer/Bio_ClinicalBERT) on an unknown dataset. It achieves the following results on the evaluation set: - Loss: 0.9746 - Accuracy: 0.88 - Precision: 0.9178 - Recall: 0.9178 - F1: 0.9178 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-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: 3 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | Accuracy | Precision | Recall | F1 | |:-------------:|:-----:|:----:|:---------------:|:--------:|:---------:|:------:|:------:| | 0.0949 | 1.0 | 50 | 1.0393 | 0.85 | 0.8816 | 0.9178 | 0.8993 | | 0.0475 | 2.0 | 100 | 1.0619 | 0.85 | 0.8816 | 0.9178 | 0.8993 | | 0.0149 | 3.0 | 150 | 0.9746 | 0.88 | 0.9178 | 0.9178 | 0.9178 | ### Framework versions - Transformers 4.21.2 - Pytorch 1.12.1+cu113 - Tokenizers 0.12.1

c42143ba868f11ba4d7dc20e46e7983d

kSaluja/new-test-model2

kSaluja

bert

transformers

token-classification

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # new-test-model2 This model is a fine-tuned version of [bert-large-uncased](https://huggingface.co/bert-large-uncased) on an unknown dataset. It achieves the following results on the evaluation set: - Loss: 0.1040 - Precision: 0.9722 - Recall: 0.9757 - F1: 0.9739 - Accuracy: 0.9808 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-05 - 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 - num_epochs: 10 ### Training results | Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1 | Accuracy | |:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:| | No log | 1.0 | 151 | 0.1819 | 0.9360 | 0.9405 | 0.9382 | 0.9540 | | No log | 2.0 | 302 | 0.1196 | 0.9637 | 0.9639 | 0.9638 | 0.9703 | | No log | 3.0 | 453 | 0.1322 | 0.9614 | 0.9682 | 0.9648 | 0.9711 | | 0.2764 | 4.0 | 604 | 0.1071 | 0.9677 | 0.9725 | 0.9701 | 0.9763 | | 0.2764 | 5.0 | 755 | 0.1084 | 0.9709 | 0.9766 | 0.9737 | 0.9790 | | 0.2764 | 6.0 | 906 | 0.1015 | 0.9717 | 0.9739 | 0.9728 | 0.9791 | | 0.0342 | 7.0 | 1057 | 0.1208 | 0.9686 | 0.9727 | 0.9706 | 0.9785 | | 0.0342 | 8.0 | 1208 | 0.1068 | 0.9680 | 0.9752 | 0.9716 | 0.9798 | | 0.0342 | 9.0 | 1359 | 0.1028 | 0.9719 | 0.9743 | 0.9731 | 0.9807 | | 0.0129 | 10.0 | 1510 | 0.1040 | 0.9722 | 0.9757 | 0.9739 | 0.9808 | ### Framework versions - Transformers 4.18.0 - Pytorch 1.11.0+cu113 - Datasets 2.1.0 - Tokenizers 0.12.1

f12660b975911f1b3a692931bcbadc8d

Helsinki-NLP/opus-mt-hy-en

Helsinki-NLP

marian

transformers

translation

apache-2.0

['translation']

### opus-mt-hy-en * source languages: hy * target languages: en * OPUS readme: [hy-en](https://github.com/Helsinki-NLP/OPUS-MT-train/blob/master/models/hy-en/README.md) * dataset: opus * model: transformer-align * pre-processing: normalization + SentencePiece * download original weights: [opus-2019-12-18.zip](https://object.pouta.csc.fi/OPUS-MT-models/hy-en/opus-2019-12-18.zip) * test set translations: [opus-2019-12-18.test.txt](https://object.pouta.csc.fi/OPUS-MT-models/hy-en/opus-2019-12-18.test.txt) * test set scores: [opus-2019-12-18.eval.txt](https://object.pouta.csc.fi/OPUS-MT-models/hy-en/opus-2019-12-18.eval.txt) ## Benchmarks | testset | BLEU | chr-F | |-----------------------|-------|-------| | Tatoeba.hy.en | 29.5 | 0.466 |

85ae1b911f80c333af96c75f2d35f3bd

popcornell/chime7_task1_asr1_baseline

popcornell

espnet

automatic-speech-recognition

cc-by-4.0

['en']

['chime7_task1']

['espnet', 'audio', 'automatic-speech-recognition', 'speech separation']

## ESPnet2 ASR model ### `popcornell/chime7_task1_asr1_baseline` This model was trained by popcornell using chime7_task1 recipe in [espnet](https://github.com/espnet/espnet/). ### Demo: How to use in ESPnet2 Follow the [CHiME-7 DASR installation instructions](https://github.com/espnet/espnet/blob/master/egs2/chime7_task1/asr1/README.md) if you haven't done that already. ```bash cd espnet git checkout 15646109f254de8b39bbe310827d617da5ac858d # follow installation instruction for CHiME-7 DASR recipe https://github.com/espnet/espnet/blob/master/egs2/chime7_task1/asr1/README.md ./run.sh --decode-only 1 --use-pretrained popcornell/chime7_task1_asr1_baseline --ngpu PUT YOURS ``` <!-- Generated by scripts/utils/show_asr_result.sh --> # RESULTS See [CHiME-7 DASR README.md](https://github.com/espnet/espnet/blob/master/egs2/chime7_task1/asr1/README.md) ## Environments - date: `Wed Feb 8 23:41:28 UTC 2023` - python version: `3.9.2 (default, Mar 3 2021, 20:02:32) [GCC 7.3.0]` - espnet version: `espnet 202301` - pytorch version: `pytorch 1.13.1+cu116` - Git hash: `` - Commit date: `` ## ASR config <details><summary>expand</summary> ``` config: conf/tuning/train_asr_transformer_wavlm_lr1e-4_specaugm_accum1_preenc128_warmup20k.yaml print_config: false log_level: INFO dry_run: false iterator_type: sequence output_dir: exp/asr_train_asr_transformer_wavlm_lr1e-4_specaugm_accum1_preenc128_warmup20k_raw_en_bpe500_batch_size640_scheduler_confwarmup_steps8000_max_epoch8_optim_conflr0.000500000000_sp ngpu: 1 seed: 0 num_workers: 1 num_att_plot: 3 dist_backend: nccl dist_init_method: env:// dist_world_size: 5 dist_rank: 0 local_rank: 0 dist_master_addr: localhost dist_master_port: 44341 dist_launcher: null multiprocessing_distributed: true unused_parameters: true sharded_ddp: false cudnn_enabled: true cudnn_benchmark: false cudnn_deterministic: true collect_stats: false write_collected_feats: false max_epoch: 8 patience: 4 val_scheduler_criterion: - valid - loss early_stopping_criterion: - valid - loss - min best_model_criterion: - - valid - acc - max keep_nbest_models: 5 nbest_averaging_interval: 0 grad_clip: 5 grad_clip_type: 2.0 grad_noise: false accum_grad: 1 no_forward_run: false resume: true train_dtype: float32 use_amp: false log_interval: null use_matplotlib: true use_tensorboard: true create_graph_in_tensorboard: false use_wandb: false wandb_project: null wandb_id: null wandb_entity: null wandb_name: null wandb_model_log_interval: -1 detect_anomaly: false pretrain_path: null init_param: [] ignore_init_mismatch: false freeze_param: - frontend.upstream num_iters_per_epoch: null batch_size: 640 valid_batch_size: null batch_bins: 1000000 valid_batch_bins: null train_shape_file: - exp/asr_stats_raw_en_bpe500_sp/train/speech_shape - exp/asr_stats_raw_en_bpe500_sp/train/text_shape.bpe valid_shape_file: - exp/asr_stats_raw_en_bpe500_sp/valid/speech_shape - exp/asr_stats_raw_en_bpe500_sp/valid/text_shape.bpe batch_type: folded valid_batch_type: null fold_length: - 80000 - 150 sort_in_batch: descending sort_batch: descending multiple_iterator: false chunk_length: 500 chunk_shift_ratio: 0.5 num_cache_chunks: 1024 train_data_path_and_name_and_type: - - dump/raw/kaldi/train_all_mdm_ihm_rvb_gss_sp/wav.scp - speech - sound - - dump/raw/kaldi/train_all_mdm_ihm_rvb_gss_sp/text - text - text valid_data_path_and_name_and_type: - - dump/raw/kaldi/chime6/dev/gss/wav.scp - speech - sound - - dump/raw/kaldi/chime6/dev/gss/text - text - text allow_variable_data_keys: false max_cache_size: 0.0 max_cache_fd: 32 valid_max_cache_size: null exclude_weight_decay: false exclude_weight_decay_conf: {} optim: adam optim_conf: lr: 0.0005 scheduler: warmuplr scheduler_conf: warmup_steps: 8000 token_list: - <blank> - <unk> - s - '''' - ▁i - t - ▁it - ▁a - e - ▁you - ▁the - ▁like - ▁yeah - a - d - ▁and - m - ▁that - ▁to - n - i - y - ing - o - u - ▁so - p - ▁of - ▁in - re - ▁was - c - r - ▁just - er - ▁know - ▁oh - ed - ▁but - ▁ummm - ▁we - l - ▁no - ▁they - ▁have - ▁do - g - ▁he - k - ll - ▁uhhh - ▁don - ▁for - h - ▁what - ▁be - ar - ▁is - ▁there - '-' - ▁s - ▁this - in - b - ▁ - en - ▁on - ▁p - ▁can - al - ▁not - w - ▁my - ▁one - ic - f - ▁or - ▁really - ▁go - ▁right - ▁me - an - ▁w - or - le - ▁f - ▁think - ▁okay - ▁all - ▁then - ▁with - ▁are - ▁get - it - ▁t - ▁st - ve - ▁hmmm - ▁g - ▁if - ce - 'on' - ▁she - ▁good - ▁e - es - ▁well - v - ▁re - th - ter - ch - ▁out - ▁up - ly - ▁b - ▁ma - il - ▁would - ▁at - ▁want - ▁mean - ▁ch - ▁your - ▁people - ur - ▁how - ▁k - ▁co - ▁about - ▁tr - ▁ba - ▁kind - ▁when - ▁mi - ▁because - ro - ▁had - ▁ho - ▁gonna - ▁time - ▁more - ▁got - ▁some - ▁two - ▁did - ▁see - ▁now - ▁pa - ra - ▁de - ▁lot - ▁actually - ▁o - ▁too - ate - ▁here - ▁cuz - ▁sp - ▁where - ▁going - ▁j - ▁from - ▁bo - ▁them - ▁bu - ▁put - ▁thing - ng - ▁were - ▁n - ▁sh - ▁work - el - ▁something - ▁se - ▁say - ke - ow - ▁ca - ▁fa - ▁need - sh - ▁di - ▁po - ▁make - la - ▁br - ▁v - ▁an - ▁who - ion - ▁y - ▁look - ▁didn - ▁could - ▁little - ver - ▁c - ▁mo - ▁much - ▁very - ir - ▁sa - ▁play - ▁pretty - ▁been - ▁d - ▁other - ▁year - and - ▁mm - ▁stuff - ▁dr - ▁why - ▁con - ▁su - ▁back - ▁ex - ting - ▁take - ▁li - ▁even - ▁should - ▁her - ally - lo - ation - ▁way - ▁guess - ▁has - z - ▁three - ry - ▁ha - ies - is - x - ▁ro - ▁yes - ▁th - ▁use - ▁down - ous - ▁over - ▁probably - ▁guys - ▁maybe - ▁still - ▁cr - ▁which - ▁nice - und - ▁sure - ▁l - ▁off - ▁la - ▁cu - est - ▁any - ▁fi - ▁these - ▁ra - ▁went - ▁things - ment - ▁doing - ▁day - ▁un - ▁lo - ▁da - ▁only - igh - ▁come - ▁big - ▁those - ▁wanna - ▁bit - ▁never - ▁us - ol - ▁though - ▁first - ive - ▁their - ▁let - ▁start - ▁his - ▁four - ▁le - ▁eat - ist - ▁school - us - ▁into - ▁yep - uck - ▁than - ▁him - ▁hi - ▁also - ▁five - side - ▁new - ▁comp - ▁cool - ▁talk - ▁said - ▁pro - ▁r - ▁always - ▁ri - ▁cl - ▁long - able - ▁sc - ▁gra - ▁by - ▁friend - age - ▁different - ▁live - ▁doesn - ▁place - ▁sorry - ▁will - ▁feel - ▁does - ▁part - ▁wait - ▁six - ▁watch - ▁anything - ▁man - ▁our - ▁car - ▁huh - ▁whatever - ▁last - ▁give - ▁ten - ▁before - ▁thought - ▁after - ▁game - ▁card - ▁fl - ▁every - cause - ▁same - ▁around - ▁cook - ▁week - ▁hu - ▁everything - ▁fine - ▁many - ▁qu - ▁read - ▁tea - ough - ance - ▁turn - ▁wow - ▁fun - ▁hard - ▁great - ▁love - ▁remember - ▁twenty - ▁whole - ▁happen - ▁seven - ▁keep - ▁food - ▁most - j - ▁might - ▁thank - ▁move - ▁job - ▁eight - ▁mu - ▁sort - ▁better - port - ▁another - ful - ▁point - ▁show - ▁again - ▁high - ize - ▁house - ▁home - ▁person - ▁old - ▁end - ▁through - ▁pick - ▁else - ▁guy - ▁app - ▁find - ▁nine - ▁hand - ▁kid - ▁interesting - ▁city - ▁called - ▁tell - ▁half - ▁name - ▁definitely - ▁made - ▁exactly - ▁came - ▁wood - ▁funny - ▁basically - ▁count - ▁usually - ▁help - ▁someone - ▁already - ▁dunno - ▁enough - ction - ▁own - ▁weird - ▁next - ▁hundred - ▁small - ▁money - ▁couple - ▁while - ▁close - ▁movie - ▁sometimes - ▁everyone - ▁away - ▁true - ▁super - ▁cheese - ▁class - ▁night - ▁life - ▁leave - ▁plan - ▁water - ▁left - ▁thirty - ▁family - ▁phone - ▁build - ▁room - ▁month - ▁open - ▁idea - ▁second - ▁dude - ▁music - ▁each - ▁learn - ▁girl - ▁together - ▁under - ▁run - ▁chicken - ▁having - ▁either - ▁almost - ▁crazy - ▁book - ▁sauce - ▁supposed - ▁course - ▁speak - ▁awesome - ▁anyway - ▁throw - ▁finish - ▁world - ▁reason - ▁check - ▁least - ▁parents - ▁everybody - ▁change - '&' - ä - '#' - ñ - â - é - ü - ']' - q - î - <sos/eos> init: xavier_uniform input_size: null ctc_conf: dropout_rate: 0.0 ctc_type: builtin reduce: true ignore_nan_grad: null zero_infinity: true joint_net_conf: null use_preprocessor: true token_type: bpe bpemodel: data/en_token_list/bpe_unigram500/bpe.model non_linguistic_symbols: data/nlsyms.txt cleaner: null g2p: null speech_volume_normalize: null rir_scp: null rir_apply_prob: 1.0 noise_scp: null noise_apply_prob: 1.0 noise_db_range: '13_15' short_noise_thres: 0.5 aux_ctc_tasks: [] frontend: s3prl frontend_conf: frontend_conf: upstream: wavlm_large download_dir: ./hub multilayer_feature: true fs: 16k specaug: specaug specaug_conf: apply_time_warp: false time_warp_window: 5 time_warp_mode: bicubic apply_freq_mask: false freq_mask_width_range: - 0 - 150 num_freq_mask: 4 apply_time_mask: true time_mask_width_ratio_range: - 0.0 - 0.15 num_time_mask: 3 normalize: utterance_mvn normalize_conf: {} model: espnet model_conf: ctc_weight: 0.3 lsm_weight: 0.1 length_normalized_loss: false extract_feats_in_collect_stats: false preencoder: linear preencoder_conf: input_size: 1024 output_size: 128 dropout: 0.2 encoder: transformer encoder_conf: output_size: 256 attention_heads: 4 linear_units: 2048 num_blocks: 12 dropout_rate: 0.1 attention_dropout_rate: 0.0 input_layer: conv2d2 normalize_before: true postencoder: null postencoder_conf: {} decoder: transformer decoder_conf: input_layer: embed attention_heads: 4 linear_units: 2048 num_blocks: 6 dropout_rate: 0.1 positional_dropout_rate: 0.0 self_attention_dropout_rate: 0.0 src_attention_dropout_rate: 0.0 preprocessor: default preprocessor_conf: {} required: - output_dir - token_list version: '202301' distributed: true ``` </details> ### Citing ESPnet ```BibTex @inproceedings{watanabe2018espnet, author={Shinji Watanabe and Takaaki Hori and Shigeki Karita and Tomoki Hayashi and Jiro Nishitoba and Yuya Unno and Nelson Yalta and Jahn Heymann and Matthew Wiesner and Nanxin Chen and Adithya Renduchintala and Tsubasa Ochiai}, title={{ESPnet}: End-to-End Speech Processing Toolkit}, year={2018}, booktitle={Proceedings of Interspeech}, pages={2207--2211}, doi={10.21437/Interspeech.2018-1456}, url={http://dx.doi.org/10.21437/Interspeech.2018-1456} } ``` or arXiv: ```bibtex @misc{watanabe2018espnet, title={ESPnet: End-to-End Speech Processing Toolkit}, author={Shinji Watanabe and Takaaki Hori and Shigeki Karita and Tomoki Hayashi and Jiro Nishitoba and Yuya Unno and Nelson Yalta and Jahn Heymann and Matthew Wiesner and Nanxin Chen and Adithya Renduchintala and Tsubasa Ochiai}, year={2018}, eprint={1804.00015}, archivePrefix={arXiv}, primaryClass={cs.CL} } ```

445aeb1f46c12b854264b9da438a80c1

minjibi/test1000v2

minjibi

wav2vec2

transformers

automatic-speech-recognition

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # test1000v2 This model is a fine-tuned version of [facebook/wav2vec2-large-xlsr-53](https://huggingface.co/facebook/wav2vec2-large-xlsr-53) on the None dataset. It achieves the following results on the evaluation set: - Loss: 0.7873 - Wer: 0.6162 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 0.001 - train_batch_size: 16 - eval_batch_size: 8 - seed: 42 - gradient_accumulation_steps: 2 - total_train_batch_size: 32 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - lr_scheduler_warmup_steps: 500 - num_epochs: 20 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | Wer | |:-------------:|:-----:|:----:|:---------------:|:------:| | 7.7913 | 3.22 | 100 | 3.3481 | 1.0 | | 3.3831 | 6.44 | 200 | 3.3229 | 1.0 | | 3.3778 | 9.67 | 300 | 3.3211 | 1.0 | | 3.3671 | 12.89 | 400 | 3.2973 | 1.0 | | 3.3528 | 16.13 | 500 | 3.1349 | 1.0 | | 1.8611 | 19.35 | 600 | 0.7873 | 0.6162 | ### Framework versions - Transformers 4.22.2 - Pytorch 1.10.0+cu102 - Datasets 1.4.1 - Tokenizers 0.12.1

367a1b02d526e0d712b87447f337eb8c

ibm/ColD-Fusion-itr21-seed2

ibm

roberta

transformers

text-classification

mit

['en']

['exbert']

# ColD Fusion model Finetuned model that aims to be a great base model. It improves over RoBERTa base, trained on 35 datasets. Full details at [this paper](https://arxiv.org/abs/2212.01378). ## Paper Abstract: Pretraining has been shown to scale well with compute, data size and data diversity. Multitask learning trains on a mixture of supervised datasets and produces improved performance compared to self-supervised pretraining. Until now, massively multitask learning required simultaneous access to all datasets in the mixture and heavy compute resources that are only available to well-resourced teams. In this paper, we propose ColD Fusion, a method that provides the benefits of multitask learning but leverages distributed computation and requires limited communication and no sharing of data. Consequentially, ColD Fusion can create a synergistic loop, where finetuned models can be recycled to continually improve the pretrained model they are based on. We show that ColD Fusion yields comparable benefits to multitask pretraining by producing a model that (a) attains strong performance on all of the datasets it was multitask trained on and (b) is a better starting point for finetuning on unseen datasets. We find ColD Fusion outperforms RoBERTa and even previous multitask models. Specifically, when training and testing on 35 diverse datasets, ColD Fusion-based model outperforms RoBERTa by 2.45 points in average without any changes to the architecture. ### How to use Best way to use is to finetune on your own task, but you can also extract features directly. To get the features of a given text in PyTorch: ```python from transformers import RobertaTokenizer, RobertaModel tokenizer = RobertaTokenizer.from_pretrained('ibm/ColD-Fusion') model = RobertaModel.from_pretrained('ibm/ColD-Fusion') 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 RobertaTokenizer, TFRobertaModel tokenizer = RobertaTokenizer.from_pretrained('ibm/ColD-Fusion') model = TFRobertaModel.from_pretrained('ibm/ColD-Fusion') text = "Replace me by any text you'd like." encoded_input = tokenizer(text, return_tensors='tf') output = model(encoded_input) ``` ## Evaluation results See full evaluation results of this model and many more [here](https://ibm.github.io/model-recycling/roberta-base_table.html) When fine-tuned on downstream tasks, this model achieves the following results: ### BibTeX entry and citation info ```bibtex @article{ColDFusion, author = {Shachar Don-Yehiya, Elad Venezian, Colin Raffel, Noam Slonim, Yoav Katz, Leshem ChoshenYinhan Liu and}, title = {ColD Fusion: Collaborative Descent for Distributed Multitask Finetuning}, journal = {CoRR}, volume = {abs/2212.01378}, year = {2022}, url = {https://arxiv.org/abs/2212.01378}, archivePrefix = {arXiv}, eprint = {2212.01378}, } ``` <a href="https://huggingface.co/exbert/?model=ibm/ColD-Fusion"> <img width="300px" src="https://cdn-media.huggingface.co/exbert/button.png"> </a>

5c8fa2b9a466ea10f283dd893ce2d1a5

Kurapka/koja

Kurapka

diffusers

text-to-image

creativeml-openrail-m

['text-to-image', 'stable-diffusion']

### koja Dreambooth model trained by Kurapka with [TheLastBen's fast-DreamBooth](https://colab.research.google.com/github/TheLastBen/fast-stable-diffusion/blob/main/fast-DreamBooth.ipynb) notebook Test the concept via A1111 Colab [fast-Colab-A1111](https://colab.research.google.com/github/TheLastBen/fast-stable-diffusion/blob/main/fast_stable_diffusion_AUTOMATIC1111.ipynb) Or you can run your new concept via `diffusers` [Colab Notebook for Inference](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/sd_dreambooth_inference.ipynb) Sample pictures of this concept:

469cbb48bbcbaa34569f445e688eabe1

jonatasgrosman/exp_w2v2t_sv-se_r-wav2vec2_s418

jonatasgrosman

wav2vec2

transformers

automatic-speech-recognition

apache-2.0

['sv-SE']

['mozilla-foundation/common_voice_7_0']

['automatic-speech-recognition', 'sv-SE']

# exp_w2v2t_sv-se_r-wav2vec2_s418 Fine-tuned [facebook/wav2vec2-large-robust](https://huggingface.co/facebook/wav2vec2-large-robust) for speech recognition using the train split of [Common Voice 7.0 (sv-SE)](https://huggingface.co/datasets/mozilla-foundation/common_voice_7_0). When using this model, make sure that your speech input is sampled at 16kHz. This model has been fine-tuned by the [HuggingSound](https://github.com/jonatasgrosman/huggingsound) tool.

68a2706abb7fec9a7d722f709415d789

MortalSage/Strange_Dedication

MortalSage

text-to-image

unknown

['en']

['stable-diffusion', 'text-to-image']

.safetensor model for automatic1111 webui. Strange_Dedication_v3 is an improvement to Strange_Dedication_v2 using Anything_v4.5. It's better at the cutesexyrobutts style, without having to use a trigger. Also, it's good at shiny_skin and shiny_clothes and artistical backgrounds. I have only used it with "vae-ft-mse-840000-ema-pruned", CLIP-Skip 1 and with danbooru tags. Lately I have started using the negative embed "bad-hands-5" (by an unknown author?), which was used for the example images as well. If you work with those you should be able to prompt images like these (prompts in .png metadata):    

2ac69240c9ec8a6839e66c10c790cb88

Sa1i/gakki-mix-512-young

Sa1i

diffusers

text-to-image

creativeml-openrail-m

['text-to-image', 'stable-diffusion', 'gakki']

# VAE Highly recommended for use with VAE # legal & risk ⚠️⚠ It is prohibited to use this model for commercial purposes and any scenarios of illegal acts and purposes. Sample pictures of this concept:   

e2e411d950545015996011bb76f95a94

bigmorning/whisper_havest_0015

bigmorning

whisper

transformers

automatic-speech-recognition

apache-2.0

['generated_from_keras_callback']

<!-- This model card has been generated automatically according to the information Keras had access to. You should probably proofread and complete it, then remove this comment. --> # whisper_havest_0015 This model is a fine-tuned version of [openai/whisper-tiny](https://huggingface.co/openai/whisper-tiny) on an unknown dataset. It achieves the following results on the evaluation set: - Train Loss: 4.5508 - Train Accuracy: 0.0121 - Train Do Wer: 1.0 - Validation Loss: 4.7620 - Validation Accuracy: 0.0121 - Validation Do Wer: 1.0 - Epoch: 14 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - optimizer: {'name': 'AdamWeightDecay', 'learning_rate': 1e-05, 'decay': 0.0, 'beta_1': 0.9, 'beta_2': 0.999, 'epsilon': 1e-07, 'amsgrad': False, 'weight_decay_rate': 0.01} - training_precision: float32 ### Training results | Train Loss | Train Accuracy | Train Do Wer | Validation Loss | Validation Accuracy | Validation Do Wer | Epoch | |:----------:|:--------------:|:------------:|:---------------:|:-------------------:|:-----------------:|:-----:| | 9.9191 | 0.0046 | 1.0 | 8.5836 | 0.0067 | 1.0 | 0 | | 8.0709 | 0.0083 | 1.0 | 7.4667 | 0.0089 | 1.0 | 1 | | 7.1652 | 0.0100 | 1.0 | 6.8204 | 0.0112 | 1.0 | 2 | | 6.7196 | 0.0114 | 1.0 | 6.5192 | 0.0114 | 1.0 | 3 | | 6.4115 | 0.0115 | 1.0 | 6.2357 | 0.0115 | 1.0 | 4 | | 6.1085 | 0.0115 | 1.0 | 5.9657 | 0.0115 | 1.0 | 5 | | 5.8206 | 0.0115 | 1.0 | 5.7162 | 0.0115 | 1.0 | 6 | | 5.5567 | 0.0115 | 1.0 | 5.4963 | 0.0115 | 1.0 | 7 | | 5.3223 | 0.0116 | 1.0 | 5.3096 | 0.0116 | 1.0 | 8 | | 5.1222 | 0.0117 | 1.0 | 5.1600 | 0.0117 | 1.0 | 9 | | 4.9580 | 0.0117 | 1.0 | 5.0391 | 0.0118 | 1.0 | 10 | | 4.8251 | 0.0119 | 1.0 | 4.9427 | 0.0118 | 1.0 | 11 | | 4.7171 | 0.0119 | 1.0 | 4.8691 | 0.0119 | 1.0 | 12 | | 4.6284 | 0.0121 | 1.0 | 4.8123 | 0.0120 | 1.0 | 13 | | 4.5508 | 0.0121 | 1.0 | 4.7620 | 0.0121 | 1.0 | 14 | ### Framework versions - Transformers 4.25.0.dev0 - TensorFlow 2.9.2 - Datasets 2.6.1 - Tokenizers 0.13.2

7d22385a960de6372ace2a5ceff99557

jcblaise/electra-tagalog-small-uncased-generator

jcblaise

electra

transformers

fill-mask

gpl-3.0

['tl']

['electra', 'tagalog', 'filipino']

# ELECTRA Tagalog Small Uncased Generator Tagalog ELECTRA model pretrained with a large corpus scraped from the internet. This model is part of a larger research project. We open-source the model to allow greater usage within the Filipino NLP community. This is the generator model used to sample synthetic text and pretrain the discriminator. Only use this model for retraining and mask-filling. For the actual model for downstream tasks, please refer to the discriminator models. ## Citations All model details and training setups can be found in our papers. If you use our model or find it useful in your projects, please cite our work: ``` @inproceedings{cruz2021exploiting, title={Exploiting News Article Structure for Automatic Corpus Generation of Entailment Datasets}, author={Cruz, Jan Christian Blaise and Resabal, Jose Kristian and Lin, James and Velasco, Dan John and Cheng, Charibeth}, booktitle={Pacific Rim International Conference on Artificial Intelligence}, pages={86--99}, year={2021}, organization={Springer} } ``` ## Data and Other Resources Data used to train this model as well as other benchmark datasets in Filipino can be found in my website at https://blaisecruz.com ## Contact If you have questions, concerns, or if you just want to chat about NLP and low-resource languages in general, you may reach me through my work email at [email protected]

8b6ffc4dd3c28bb5c24f4a941aa87675

arvkevi/nba_pbp_distilgpt2

arvkevi

gpt2

transformers

text-generation

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # nba_pbp_distilgpt2 This model is a fine-tuned version of [distilgpt2](https://huggingface.co/distilgpt2) on text files containing play-by-play descriptions of games played by the Boston Celtics and Golden State Warriors during the 2021-22 NBA season. It achieves the following results on the evaluation set: - Loss: 0.6324 - Accuracy: 0.8117 ## Model description This model will generate properly formatted play-by-play descriptions of an NBA game with players from the Boston Celtics and Golden State Warriors. ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - train_batch_size: 4 - eval_batch_size: 4 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 3.0 ### Training results ### Framework versions - Transformers 4.22.0.dev0 - Pytorch 1.12.1+cu113 - Datasets 2.4.0 - Tokenizers 0.12.1

8350dd6b5f7786145e6b0bef1e2ad520

muhtasham/small-mlm-glue-qqp-custom-tokenizer

muhtasham

bert

transformers

fill-mask

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # small-mlm-glue-qqp-custom-tokenizer This model is a fine-tuned version of [google/bert_uncased_L-4_H-512_A-8](https://huggingface.co/google/bert_uncased_L-4_H-512_A-8) on the None dataset. It achieves the following results on the evaluation set: - Loss: 5.0065 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 3e-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: constant - num_epochs: 200 ### Training results | Training Loss | Epoch | Step | Validation Loss | |:-------------:|:-----:|:-----:|:---------------:| | 6.3631 | 0.4 | 500 | 5.9145 | | 5.6422 | 0.8 | 1000 | 5.8224 | | 5.4368 | 1.2 | 1500 | 5.6172 | | 5.1539 | 1.6 | 2000 | 5.4872 | | 5.0641 | 2.0 | 2500 | 5.5369 | | 4.9495 | 2.4 | 3000 | 5.3466 | | 4.8947 | 2.8 | 3500 | 5.4592 | | 4.9081 | 3.2 | 4000 | 5.3328 | | 4.7214 | 3.6 | 4500 | 5.3746 | | 4.7341 | 4.0 | 5000 | 5.3417 | | 4.6482 | 4.4 | 5500 | 5.2731 | | 4.628 | 4.8 | 6000 | 5.2716 | | 4.5801 | 5.2 | 6500 | 5.1364 | | 4.4967 | 5.6 | 7000 | 5.2167 | | 4.4984 | 6.0 | 7500 | 5.2133 | | 4.4255 | 6.4 | 8000 | 5.1228 | | 4.4459 | 6.8 | 8500 | 5.1664 | | 4.3732 | 7.2 | 9000 | 5.0800 | | 4.2546 | 7.6 | 9500 | 5.0616 | | 4.351 | 8.0 | 10000 | 5.1500 | | 4.2365 | 8.4 | 10500 | 5.0903 | | 4.2224 | 8.8 | 11000 | 5.0041 | | 4.2549 | 9.2 | 11500 | 5.0711 | | 4.1108 | 9.6 | 12000 | 5.1525 | | 4.1366 | 10.0 | 12500 | 5.0065 | ### Framework versions - Transformers 4.26.0.dev0 - Pytorch 1.13.0+cu116 - Datasets 2.8.1.dev0 - Tokenizers 0.13.2

aedf9d49499f69fb9e8b14113d294bb2

jonatasgrosman/exp_w2v2r_de_xls-r_age_teens-8_sixties-2_s945

jonatasgrosman

wav2vec2

transformers

automatic-speech-recognition

apache-2.0

['de']

['mozilla-foundation/common_voice_7_0']

['automatic-speech-recognition', 'de']

# exp_w2v2r_de_xls-r_age_teens-8_sixties-2_s945 Fine-tuned [facebook/wav2vec2-xls-r-300m](https://huggingface.co/facebook/wav2vec2-xls-r-300m) for speech recognition using the train split of [Common Voice 7.0 (de)](https://huggingface.co/datasets/mozilla-foundation/common_voice_7_0). When using this model, make sure that your speech input is sampled at 16kHz. This model has been fine-tuned by the [HuggingSound](https://github.com/jonatasgrosman/huggingsound) tool.

eeff3a02f55872ba95b04bc82f8f8efd

2020uee0139/distilbert-base-uncased-finetuned-squad

2020uee0139

distilbert

transformers

question-answering

apache-2.0

['squad']

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # distilbert-base-uncased-finetuned-squad This model is a fine-tuned version of [distilbert-base-uncased](https://huggingface.co/distilbert-base-uncased) on the squad dataset. It achieves the following results on the evaluation set: - Loss: 1.1547 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-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: 3 ### Training results | Training Loss | Epoch | Step | Validation Loss | |:-------------:|:-----:|:-----:|:---------------:| | 1.2164 | 1.0 | 5533 | 1.1486 | | 0.9546 | 2.0 | 11066 | 1.1251 | | 0.7573 | 3.0 | 16599 | 1.1547 | ### Framework versions - Transformers 4.25.1 - Pytorch 1.13.0+cu116 - Datasets 2.8.0 - Tokenizers 0.13.2

bdd84eba2f64d8fa267d694ea40d857a

Intel/bert-base-uncased-mrpc-int8-dynamic

Intel

bert

transformers

text-classification

apache-2.0

['en']

['mrpc']

['text-classfication', 'int8', 'Intel® Neural Compressor', 'PostTrainingDynamic', 'onnx']

# INT8 BERT base uncased finetuned MRPC ## Post-training dynamic quantization ### PyTorch This is an INT8 PyTorch model quantized with [huggingface/optimum-intel](https://github.com/huggingface/optimum-intel) through the usage of [Intel® Neural Compressor](https://github.com/intel/neural-compressor). The original fp32 model comes from the fine-tuned model [Intel/bert-base-uncased-mrpc](https://huggingface.co/Intel/bert-base-uncased-mrpc). #### Test result | |INT8|FP32| |---|:---:|:---:| | **Accuracy (eval-f1)** |0.8997|0.9042| | **Model size (MB)** |174|418| #### Load with optimum: ```python from optimum.intel.neural_compressor.quantization import IncQuantizedModelForSequenceClassification int8_model = IncQuantizedModelForSequenceClassification.from_pretrained( 'Intel/bert-base-uncased-mrpc-int8-dynamic', ) ``` ### ONNX This is an INT8 ONNX model quantized with [Intel® Neural Compressor](https://github.com/intel/neural-compressor). The original fp32 model comes from the fine-tuned model [Intel/bert-base-uncased-mrpc](https://huggingface.co/Intel/bert-base-uncased-mrpc). #### Test result | |INT8|FP32| |---|:---:|:---:| | **Accuracy (eval-f1)** |0.8958|0.9042| | **Model size (MB)** |107|418| #### Load ONNX model: ```python from optimum.onnxruntime import ORTModelForSequenceClassification model = ORTModelForSequenceClassification.from_pretrained('Intel/bert-base-uncased-mrpc-int8-dynamic') ```

439aac8e766a0d7796c3738f812e06b4

prakharz/DIAL-FLANT5-XL

prakharz

t5

transformers

text2text-generation

apache-2.0

['generated_from_trainer']

# InstructDial Instruction tuning is an emergent paradigm in NLP wherein natural language instructions are leveraged with language models to induce zero-shot performance on unseen tasks. Instructions have been shown to enable good performance on unseen tasks and datasets in both large and small language models. Dialogue is an especially interesting area to explore instruction tuning because dialogue systems perform multiple kinds of tasks related to language (e.g., natural language understanding and generation, domain-specific interaction), yet instruction tuning has not been systematically explored for dialogue-related tasks. We introduce InstructDial, an instruction tuning framework for dialogue, which consists of a repository of 48 diverse dialogue tasks in a unified text-to-text format created from 59 openly available dialogue datasets. Next, we explore cross-task generalization ability on models tuned on InstructDial across diverse dialogue tasks. Our analysis reveals that InstructDial enables good zero-shot performance on unseen datasets and tasks such as dialogue evaluation and intent detection, and even better performance in a few-shot setting. To ensure that models adhere to instructions, we introduce novel meta-tasks. We establish benchmark zero-shot and few-shot performance of models trained using the proposed framework on multiple dialogue tasks. [Paper](https://arxiv.org/abs/2205.12673) [GIT] (https://github.com/prakharguptaz/Instructdial) # DIAL-FLANT5-XL DIAL-FLANT5-XL is a 3B model trained on InstructDial tasks. This model is a fine-tuned version of google/flan-t5-xl model ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data All tasks in InstructDial framework (including all dialogue eval tasks) ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - train_batch_size: 9 - eval_batch_size: 9 - seed: 42 - distributed_type: multi-GPU - num_devices: 8 - total_train_batch_size: 72 - total_eval_batch_size: 72 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 3.0 ### Framework versions - Transformers 4.20.1 - Pytorch 1.11.0 - Datasets 2.3.2 - Tokenizers 0.12.1

8551ede43863e78a31514b0a652dc412

huggingnft/alpacadabraz

huggingnft

transformers

unconditional-image-generation

mit

['huggingnft/alpacadabraz']

['huggingnft', 'nft', 'huggan', 'gan', 'image', 'images', 'unconditional-image-generation']

# Hugging NFT: alpacadabraz ## Disclaimer All rights belong to their owners. Models and datasets can be removed from the site at the request of the copyright holder. ## Model description LightWeight GAN model for unconditional generation. NFT collection available [here](https://opensea.io/collection/alpacadabraz). Dataset is available [here](https://huggingface.co/datasets/huggingnft/alpacadabraz). Check Space: [link](https://huggingface.co/spaces/AlekseyKorshuk/huggingnft). Project repository: [link](https://github.com/AlekseyKorshuk/huggingnft). [](https://github.com/AlekseyKorshuk/huggingnft) ## Intended uses & limitations #### How to use Check project repository: [link](https://github.com/AlekseyKorshuk/huggingnft). #### Limitations and bias Check project repository: [link](https://github.com/AlekseyKorshuk/huggingnft). ## Training data Dataset is available [here](https://huggingface.co/datasets/huggingnft/alpacadabraz). ## Training procedure Training script is available [here](https://github.com/AlekseyKorshuk/huggingnft). ## Generated Images Check results with Space: [link](https://huggingface.co/spaces/AlekseyKorshuk/huggingnft). ## About *Built by Aleksey Korshuk* [](https://github.com/AlekseyKorshuk) [](https://twitter.com/intent/follow?screen_name=alekseykorshuk) [](https://t.me/joinchat/_CQ04KjcJ-4yZTky) For more details, visit the project repository. [](https://github.com/AlekseyKorshuk/huggingnft) ### BibTeX entry and citation info ```bibtex @InProceedings{huggingnft, author={Aleksey Korshuk} year=2022 } ```

8099a5c6818b8263c173d2cc7ee8d440

megantosh/flair-arabic-MSA-aqmar

megantosh

flair

token-classification

apache-2.0

['ar']

['AQMAR', 'ANERcorp']

['flair', 'Text Classification', 'token-classification', 'sequence-tagger-model']

# Arabic NER Model for AQMAR dataset Training was conducted over 86 epochs, using a linear decaying learning rate of 2e-05, starting from 0.3 and a batch size of 48 with fastText and Flair forward and backward embeddings. ## Original Dataset: - [AQMAR](http://www.cs.cmu.edu/~ark/ArabicNER/) ## Results: - F1-score (micro) 0.9323 - F1-score (macro) 0.9272 | | True Posititves | False Positives | False Negatives | Precision | Recall | class-F1 | |------|-----|----|----|---------|--------|----------| | LOC | 164 | 7 | 13 | 0.9591 | 0.9266 | 0.9425 | | MISC | 398 | 22 | 37 | 0.9476 | 0.9149 | 0.9310 | | ORG | 65 | 6 | 9 | 0.9155 | 0.8784 | 0.8966 | | PER | 199 | 13 | 13 | 0.9387 | 0.9387 | 0.9387 | --- # Usage ```python from flair.data import Sentence from flair.models import SequenceTagger import pyarabic.araby as araby from icecream import ic arTagger = SequenceTagger.load('megantosh/flair-arabic-MSA-aqmar') sentence = Sentence('George Washington went to Washington .') arSentence = Sentence('عمرو عادلي أستاذ للاقتصاد السياسي المساعد في الجامعة الأمريكية بالقاهرة .') # predict NER tags tagger.predict(sentence) arTagger.predict(arSentence) # print sentence with predicted tags ic(sentence.to_tagged_string) ic(arSentence.to_tagged_string) ``` # Example see an example from a [similar NER model in Flair](https://huggingface.co/megantosh/flair-arabic-multi-ner) # Model Configuration ```python (embeddings): StackedEmbeddings( (list_embedding_0): WordEmbeddings('ar') (list_embedding_1): FlairEmbeddings( (lm): LanguageModel( (drop): Dropout(p=0.1, inplace=False) (encoder): Embedding(7125, 100) (rnn): LSTM(100, 2048) (decoder): Linear(in_features=2048, out_features=7125, bias=True) ) ) (list_embedding_2): FlairEmbeddings( (lm): LanguageModel( (drop): Dropout(p=0.1, inplace=False) (encoder): Embedding(7125, 100) (rnn): LSTM(100, 2048) (decoder): Linear(in_features=2048, out_features=7125, bias=True) ) ) ) (word_dropout): WordDropout(p=0.05) (locked_dropout): LockedDropout(p=0.5) (embedding2nn): Linear(in_features=4396, out_features=4396, bias=True) (rnn): LSTM(4396, 256, batch_first=True, bidirectional=True) (linear): Linear(in_features=512, out_features=14, bias=True) (beta): 1.0 (weights): None (weight_tensor) None )" 2021-03-31 22:19:50,654 ---------------------------------------------------------------------------------------------------- 2021-03-31 22:19:50,654 Corpus: "Corpus: 3025 train + 336 dev + 373 test sentences" 2021-03-31 22:19:50,654 ---------------------------------------------------------------------------------------------------- 2021-03-31 22:19:50,654 Parameters: 2021-03-31 22:19:50,654 - learning_rate: "0.3" 2021-03-31 22:19:50,654 - mini_batch_size: "48" 2021-03-31 22:19:50,654 - patience: "3" 2021-03-31 22:19:50,654 - anneal_factor: "0.5" 2021-03-31 22:19:50,654 - max_epochs: "150" 2021-03-31 22:19:50,654 - shuffle: "True" 2021-03-31 22:19:50,654 - train_with_dev: "False" 2021-03-31 22:19:50,654 - batch_growth_annealing: "False" 2021-03-31 22:19:50,655 ------------------------------------ ``` Due to the right-to-left in left-to-right context, some formatting errors might occur. and your code might appear like [this](https://ibb.co/ky20Lnq), (link accessed on 2020-10-27) # Citation *if you use this model, please consider citing [this work](https://www.researchgate.net/publication/358956953_Sequence_Labeling_Architectures_in_Diglossia_-_a_case_study_of_Arabic_and_its_dialects):* ```latex @unpublished{MMHU21 author = "M. Megahed", title = "Sequence Labeling Architectures in Diglossia", year = {2021}, doi = "10.13140/RG.2.2.34961.10084" url = {https://www.researchgate.net/publication/358956953_Sequence_Labeling_Architectures_in_Diglossia_-_a_case_study_of_Arabic_and_its_dialects} } ```

11e4388388b4286db8293fe9dc815596

roscazo/CTEBMSP_ANAT_DISO

roscazo

roberta

transformers

token-classification

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # CTEBMSP_ANAT_DISO This model is a fine-tuned version of [PlanTL-GOB-ES/bsc-bio-ehr-es](https://huggingface.co/PlanTL-GOB-ES/bsc-bio-ehr-es) on the None dataset. It achieves the following results on the evaluation set: - Loss: 0.0909 - Anat Precision: 0.7522 - Anat Recall: 0.7147 - Anat F1: 0.7330 - Anat Number: 361 - Diso Precision: 0.8915 - Diso Recall: 0.8919 - Diso F1: 0.8917 - Diso Number: 2645 - Overall Precision: 0.8755 - Overall Recall: 0.8706 - Overall F1: 0.8731 - Overall Accuracy: 0.9873 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 8e-05 - 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 - num_epochs: 8 ### Training results | Training Loss | Epoch | Step | Validation Loss | Anat Precision | Anat Recall | Anat F1 | Anat Number | Diso Precision | Diso Recall | Diso F1 | Diso Number | Overall Precision | Overall Recall | Overall F1 | Overall Accuracy | |:-------------:|:-----:|:-----:|:---------------:|:--------------:|:-----------:|:-------:|:-----------:|:--------------:|:-----------:|:-------:|:-----------:|:-----------------:|:--------------:|:----------:|:----------------:| | 0.0592 | 1.0 | 2133 | 0.0506 | 0.6950 | 0.4986 | 0.5806 | 361 | 0.8635 | 0.8609 | 0.8622 | 2645 | 0.8484 | 0.8174 | 0.8326 | 0.9843 | | 0.0323 | 2.0 | 4266 | 0.0583 | 0.7899 | 0.6039 | 0.6845 | 361 | 0.8780 | 0.8817 | 0.8798 | 2645 | 0.8697 | 0.8483 | 0.8589 | 0.9858 | | 0.0201 | 3.0 | 6399 | 0.0580 | 0.6565 | 0.7147 | 0.6844 | 361 | 0.8598 | 0.8764 | 0.8680 | 2645 | 0.8339 | 0.8570 | 0.8453 | 0.9851 | | 0.0121 | 4.0 | 8532 | 0.0758 | 0.7240 | 0.6759 | 0.6991 | 361 | 0.8976 | 0.8752 | 0.8863 | 2645 | 0.8776 | 0.8513 | 0.8642 | 0.9863 | | 0.0078 | 5.0 | 10665 | 0.0814 | 0.7219 | 0.7119 | 0.7169 | 361 | 0.8776 | 0.8975 | 0.8875 | 2645 | 0.8595 | 0.8752 | 0.8673 | 0.9862 | | 0.0031 | 6.0 | 12798 | 0.0974 | 0.7599 | 0.6399 | 0.6947 | 361 | 0.8895 | 0.8915 | 0.8905 | 2645 | 0.8761 | 0.8613 | 0.8686 | 0.9867 | | 0.002 | 7.0 | 14931 | 0.0980 | 0.7143 | 0.6787 | 0.6960 | 361 | 0.8813 | 0.8957 | 0.8884 | 2645 | 0.8624 | 0.8696 | 0.8660 | 0.9860 | | 0.0005 | 8.0 | 17064 | 0.0909 | 0.7522 | 0.7147 | 0.7330 | 361 | 0.8915 | 0.8919 | 0.8917 | 2645 | 0.8755 | 0.8706 | 0.8731 | 0.9873 | ### Framework versions - Transformers 4.25.1 - Pytorch 1.13.0+cu116 - Datasets 2.8.0 - Tokenizers 0.13.2

98835688bbc75a121215ab68e234fcfc

dxiao/bert-finetuned-ner-20percent

dxiao

bert

transformers

token-classification

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # bert-finetuned-ner-20percent This model is a fine-tuned version of [bert-base-cased](https://huggingface.co/bert-base-cased) on the None dataset. It achieves the following results on the evaluation set: - Loss: 0.6513 - Precision: 0.5252 - Recall: 0.6562 - F1: 0.5834 - Accuracy: 0.8044 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-05 - train_batch_size: 8 - eval_batch_size: 8 - seed: 2022 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 3 ### Training results | Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1 | Accuracy | |:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:| | No log | 1.0 | 15 | 0.9155 | 0.3511 | 0.4264 | 0.3851 | 0.7353 | | No log | 2.0 | 30 | 0.7116 | 0.4845 | 0.6321 | 0.5485 | 0.7898 | | No log | 3.0 | 45 | 0.6513 | 0.5252 | 0.6562 | 0.5834 | 0.8044 | ### Framework versions - Transformers 4.24.0 - Pytorch 1.12.1+cu113 - Datasets 2.6.1 - Tokenizers 0.13.2

140bd2b8399a76158210abbebd816fef

Simon17/Klassifizierung-Heizung

Simon17

bert

transformers

text-classification

mit

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # Klassifizierung-Heizung This model is a fine-tuned version of [bert-base-german-cased](https://huggingface.co/bert-base-german-cased) on the None dataset. It achieves the following results on the evaluation set: - Loss: 0.0936 - F1: 0.9859 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 5e-05 - 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 - num_epochs: 3.0 ### Training results | Training Loss | Epoch | Step | Validation Loss | F1 | |:-------------:|:-----:|:----:|:---------------:|:------:| | 0.7465 | 1.0 | 142 | 0.1972 | 0.9286 | | 0.1416 | 2.0 | 284 | 0.1080 | 0.9859 | | 0.0541 | 3.0 | 426 | 0.0936 | 0.9859 | ### Framework versions - Transformers 4.22.2 - Pytorch 1.12.1+cu113 - Datasets 2.5.1 - Tokenizers 0.12.1

92a43128590c7933cb7f3d2552f8f4ec

sd-concepts-library/james-web-space-telescope

sd-concepts-library

mit

[]

### James Web space Telescope on Stable Diffusion This is the `<James-Web-Telescope>` 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`:    

1fa34a6ac260d9bca1ad288d3ec7d4a6

tau/bart-base-sled-contractnli

tau

tau/sled

transformers

mit

['en']

[]

# BART-SLED (SLiding-Encoder and Decoder, base-sized model) SLED models use pretrained, short-range encoder-decoder models, and apply them over long-text inputs by splitting the input into multiple overlapping chunks, encoding each independently and perform fusion-in-decoder ## Model description This SLED model is based on the BART model, which is described in its [model card](https://huggingface.co/facebook/bart-base). BART is particularly effective when fine-tuned for text generation (e.g. summarization, translation) but also works well for comprehension tasks (e.g. text classification, question answering). When used as a BART-SLED model, it can be applied on long text tasks. This model was finetuned on the [ContractNLI](https://arxiv.org/abs/2110.01799) ## Intended uses & limitations You can use the raw model for text infilling. However, the model is mostly meant to be fine-tuned on a supervised dataset. ### How to use To use the model, you first need to install `py-sled` in your environment (or clone the code from the [official repository](https://github.com/Mivg/SLED/blob/main/README.md)) ``` pip install py-sled ``` For more installation instructions, see [here](https://github.com/Mivg/SLED#Installation). Once installed, SLED is fully compatible with HuggingFace's AutoClasses (AutoTokenizer, AutoConfig, AutoModel and AutoModelForCausalLM) and can be loaded using the from_pretrained methods ```python import sled # *** required so that SledModels will be registered for the AutoClasses *** model = AutoModel.from_pretrained('tau/bart-base-sled') ``` Here is how to use this model in PyTorch: ```python from sled import SledTokenizer, SledModel tokenizer = SledTokenizer.from_pretrained('tau/bart-base-sled') model = SledModel.from_pretrained('tau/bart-base-sled') inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") outputs = model(**inputs) last_hidden_states = outputs.last_hidden_state ``` You can also replace SledModel by SledModelForConditionalGeneration for Seq2Seq generation ```python model = SledModelForConditionalGeneration.from_pretrained('tau/bart-base-sled') ``` In case you wish to apply SLED on a task containing a prefix (e.g. question) which should be given as a context to every chunk, you can pass the `prefix_length` tensor input as well (A LongTensor in the length of the batch size). ```python import torch import sled # *** required so that SledModels will be registered for the AutoClasses *** tokenizer = AutoTokenizer.from_pretrained('tau/bart-base-sled') model = AutoModel.from_pretrained('tau/bart-base-sled') document_input_ids = tokenizer("Dogs are great for you.", return_tensors="pt").input_ids prefix_input_ids = tokenizer("Are dogs good for you?", return_tensors="pt").input_ids input_ids = torch.cat((prefix_input_ids, document_input_ids), dim=-1) attention_mask = torch.ones_like(input_ids) prefix_length = torch.LongTensor([[prefix_input_ids.size(1)]]) outputs = model(input_ids=input_ids, attention_mask=attention_mask, prefix_length=prefix_length) last_hidden_states = outputs.last_hidden_state ``` ### BibTeX entry and citation info Please cite both the SLED [paper](https://arxiv.org/abs/2208.00748.pdf) and the BART [paper](https://arxiv.org/abs/1910.13461) by Lewis et al as well as ContractNLI by Koreeda and Manning ```bibtex @inproceedings{Ivgi2022EfficientLU, title={Efficient Long-Text Understanding with Short-Text Models}, author={Maor Ivgi and Uri Shaham and Jonathan Berant}, year={2022} } ``` ```bibtex @article{DBLP:journals/corr/abs-1910-13461, author = {Mike Lewis and Yinhan Liu and Naman Goyal and Marjan Ghazvininejad and Abdelrahman Mohamed and Omer Levy and Veselin Stoyanov and Luke Zettlemoyer}, title = {{BART:} Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension}, journal = {CoRR}, volume = {abs/1910.13461}, year = {2019}, url = {http://arxiv.org/abs/1910.13461}, eprinttype = {arXiv}, eprint = {1910.13461}, timestamp = {Thu, 31 Oct 2019 14:02:26 +0100}, biburl = {https://dblp.org/rec/journals/corr/abs-1910-13461.bib}, bibsource = {dblp computer science bibliography, https://dblp.org} } ``` ```bibtex @inproceedings{koreeda-manning-2021-contractnli-dataset, title = "{C}ontract{NLI}: A Dataset for Document-level Natural Language Inference for Contracts", author = "Koreeda, Yuta and Manning, Christopher", booktitle = "Findings of the Association for Computational Linguistics: EMNLP 2021", month = nov, year = "2021", address = "Punta Cana, Dominican Republic", publisher = "Association for Computational Linguistics", url = "https://aclanthology.org/2021.findings-emnlp.164", doi = "10.18653/v1/2021.findings-emnlp.164", pages = "1907--1919" } ```

652ac6c93ae67a41b4f8d885f27845b1

thyagosme/gpt2-wikitext2

thyagosme

gpt2

transformers

text-generation

mit

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # gpt2-wikitext2 This model is a fine-tuned version of [gpt2](https://huggingface.co/gpt2) on the None dataset. It achieves the following results on the evaluation set: - Loss: 6.1095 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-05 - 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 - num_epochs: 3.0 ### Training results | Training Loss | Epoch | Step | Validation Loss | |:-------------:|:-----:|:----:|:---------------:| | 6.5576 | 1.0 | 2249 | 6.4681 | | 6.1905 | 2.0 | 4498 | 6.1976 | | 6.0005 | 3.0 | 6747 | 6.1095 | ### Framework versions - Transformers 4.16.2 - Pytorch 1.10.0+cu111 - Datasets 1.18.3 - Tokenizers 0.11.0

db207bf12cddb2e1fba07948e78679ce

omriuz/distilbert-base-uncased-finetuned-mnli

omriuz

distilbert

transformers

text-classification

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # distilbert-base-uncased-finetuned-mnli 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: - Loss: 0.8311 - Accuracy: 0.6574 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-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: 2 ### Training results | Training Loss | Epoch | Step | Validation Loss | Accuracy | |:-------------:|:-----:|:----:|:---------------:|:--------:| | 0.8687 | 1.0 | 2636 | 0.8341 | 0.6495 | | 0.7788 | 2.0 | 5272 | 0.8311 | 0.6574 | ### Framework versions - Transformers 4.21.1 - Pytorch 1.12.0+cu113 - Datasets 2.4.0 - Tokenizers 0.12.1

eb2b9fcf50cead783754391fa6a139fb

jonatasgrosman/exp_w2v2t_nl_unispeech_s493

jonatasgrosman

unispeech

transformers

automatic-speech-recognition

apache-2.0

['nl']

['mozilla-foundation/common_voice_7_0']

['automatic-speech-recognition', 'nl']

# exp_w2v2t_nl_unispeech_s493 Fine-tuned [microsoft/unispeech-large-1500h-cv](https://huggingface.co/microsoft/unispeech-large-1500h-cv) for speech recognition using the train split of [Common Voice 7.0 (nl)](https://huggingface.co/datasets/mozilla-foundation/common_voice_7_0). When using this model, make sure that your speech input is sampled at 16kHz. This model has been fine-tuned by the [HuggingSound](https://github.com/jonatasgrosman/huggingsound) tool.

835abbb190bd60eeb21e6199a2587a74

Vishfeb27/wav2vec2-base-timit-demo-colab

Vishfeb27

wav2vec2

transformers

automatic-speech-recognition

apache-2.0

['generated_from_trainer']

<!-- This model card has been generated automatically according to the information the Trainer had access to. You should probably proofread and complete it, then remove this comment. --> # wav2vec2-base-timit-demo-colab This model is a fine-tuned version of [facebook/wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base) on the None dataset. ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 0.0001 - train_batch_size: 32 - 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: 1000 - num_epochs: 1 - mixed_precision_training: Native AMP ### Training results ### Framework versions - Transformers 4.11.3 - Pytorch 1.10.0+cu111 - Datasets 1.18.3 - Tokenizers 0.10.3

7812217c55e44d62bc2b6221acd290ad

96harsh56/bert-large-cased-berta-finetuned-subjqa_1

96harsh56

bert