text stringlengths 5 58.6k | source stringclasses 470
values | url stringlengths 49 167 | source_section stringlengths 0 90 | file_type stringclasses 1
value | id stringlengths 3 6 |
|---|---|---|---|---|---|
A subfield of machine learning which focuses on learning meaningful representations of raw data. Some examples of representation learning techniques include word embeddings, autoencoders, and Generative Adversarial Networks (GANs). | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#representation-learning | #representation-learning | .md | 16_37 |
A measurement in hertz of the number of samples (the audio signal) taken per second. The sampling rate is a result of discretizing a continuous signal such as speech. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#sampling-rate | #sampling-rate | .md | 16_38 |
Each element of the input finds out which other elements of the input they should attend to. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#self-attention | #self-attention | .md | 16_39 |
A category of machine learning techniques in which a model creates its own learning objective from unlabeled data. It differs from [unsupervised learning](#unsupervised-learning) and [supervised learning](#supervised-learning) in that the learning process is supervised, but not explicitly from the user.
One example o... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#self-supervised-learning | #self-supervised-learning | .md | 16_40 |
A broad category of machine learning training techniques that leverages a small amount of labeled data with a larger quantity of unlabeled data to improve the accuracy of a model, unlike [supervised learning](#supervised-learning) and [unsupervised learning](#unsupervised-learning).
An example of a semi-supervised le... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#semi-supervised-learning | #semi-supervised-learning | .md | 16_41 |
Models that generate a new sequence from an input, like translation models, or summarization models (such as
[Bart](model_doc/bart) or [T5](model_doc/t5)). | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#sequence-to-sequence-seq2seq | #sequence-to-sequence-seq2seq | .md | 16_42 |
Another name for the foundational [ZeRO](#zero-redundancy-optimizer-zero) concept as used by various other implementations of ZeRO. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#sharded-ddp | #sharded-ddp | .md | 16_43 |
In [convolution](#convolution) or [pooling](#pooling), the stride refers to the distance the kernel is moved over a matrix. A stride of 1 means the kernel is moved one pixel over at a time, and a stride of 2 means the kernel is moved two pixels over at a time. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#stride | #stride | .md | 16_44 |
A form of model training that directly uses labeled data to correct and instruct model performance. Data is fed into the model being trained, and its predictions are compared to the known labels. The model updates its weights based on how incorrect its predictions were, and the process is repeated to optimize model per... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#supervised-learning | #supervised-learning | .md | 16_45 |
Parallelism technique for training on multiple GPUs in which each tensor is split up into multiple chunks, so instead of
having the whole tensor reside on a single GPU, each shard of the tensor resides on its designated GPU. Shards gets
processed separately and in parallel on different GPUs and the results are synced a... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#tensor-parallelism-tp | #tensor-parallelism-tp | .md | 16_46 |
A part of a sentence, usually a word, but can also be a subword (non-common words are often split in subwords) or a
punctuation symbol. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#token | #token | .md | 16_47 |
Some models' purpose is to do classification on pairs of sentences or question answering.
<Youtube id="0u3ioSwev3s"/>
These require two different sequences to be joined in a single "input_ids" entry, which usually is performed with the
help of special tokens, such as the classifier (`[CLS]`) and separator (`[SEP]`)... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#token-type-ids | #token-type-ids | .md | 16_48 |
A technique that involves taking a pretrained model and adapting it to a dataset specific to your task. Instead of training a model from scratch, you can leverage knowledge obtained from an existing model as a starting point. This speeds up the learning process and reduces the amount of training data needed. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#transfer-learning | #transfer-learning | .md | 16_49 |
Self-attention based deep learning model architecture. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#transformer | #transformer | .md | 16_50 |
A form of model training in which data provided to the model is not labeled. Unsupervised learning techniques leverage statistical information of the data distribution to find patterns useful for the task at hand. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#unsupervised-learning | #unsupervised-learning | .md | 16_51 |
Parallelism technique which performs sharding of the tensors somewhat similar to [TensorParallel](#tensor-parallelism-tp),
except the whole tensor gets reconstructed in time for a forward or backward computation, therefore the model doesn't need
to be modified. This method also supports various offloading techniques to... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/glossary.md | https://huggingface.co/docs/transformers/en/glossary/#zero-redundancy-optimizer-zero | #zero-redundancy-optimizer-zero | .md | 16_52 |
<!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agr... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/tf_xla.md | https://huggingface.co/docs/transformers/en/tf_xla/ | .md | 17_0 | |
[[open-in-colab]]
Accelerated Linear Algebra, dubbed XLA, is a compiler for accelerating the runtime of TensorFlow Models. From the [official documentation](https://www.tensorflow.org/xla):
XLA (Accelerated Linear Algebra) is a domain-specific compiler for linear algebra that can accelerate TensorFlow models with p... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/tf_xla.md | https://huggingface.co/docs/transformers/en/tf_xla/#xla-integration-for-tensorflow-models | #xla-integration-for-tensorflow-models | .md | 17_1 |
Let us consider the following model in TensorFlow:
```py
import tensorflow as tf
model = tf.keras.Sequential(
[tf.keras.layers.Dense(10, input_shape=(10,), activation="relu"), tf.keras.layers.Dense(5, activation="softmax")]
)
```
The above model accepts inputs having a dimension of `(10, )`. We can use the model f... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/tf_xla.md | https://huggingface.co/docs/transformers/en/tf_xla/#running-tf-functions-with-xla | #running-tf-functions-with-xla | .md | 17_2 |
To enable XLA-accelerated generation within 🤗 Transformers, you need to have a recent version of `transformers` installed. You can install it by running:
```bash
pip install transformers --upgrade
```
And then you can run the following code:
```py
import tensorflow as tf
from transformers import AutoTokenizer, T... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/tf_xla.md | https://huggingface.co/docs/transformers/en/tf_xla/#running-a-tf-text-generation-model-with-xla-from--transformers | #running-a-tf-text-generation-model-with-xla-from--transformers | .md | 17_3 |
When you are executing an XLA-enabled function (like `xla_generate()` above) for the first time, it will internally try to infer the computation graph, which is time-consuming. This process is known as [“tracing”](https://www.tensorflow.org/guide/intro_to_graphs#when_is_a_function_tracing).
You might notice that the... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/tf_xla.md | https://huggingface.co/docs/transformers/en/tf_xla/#gotchas-to-be-aware-of | #gotchas-to-be-aware-of | .md | 17_4 |
Here, we leave you with some additional resources if you want to delve deeper into XLA in 🤗 Transformers and in general.
* [This Colab Notebook](https://colab.research.google.com/github/huggingface/blog/blob/main/notebooks/91_tf_xla_generate.ipynb) provides an interactive demonstration if you want to fiddle with the... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/tf_xla.md | https://huggingface.co/docs/transformers/en/tf_xla/#additional-resources | #additional-resources | .md | 17_5 |
<!--Copyright 2024 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_optims.md | https://huggingface.co/docs/transformers/en/llm_optims/ | .md | 18_0 | |
Large language models (LLMs) have pushed text generation applications, such as chat and code completion models, to the next level by producing text that displays a high level of understanding and fluency. But what makes LLMs so powerful - namely their size - also presents challenges for inference.
Basic inference is ... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_optims.md | https://huggingface.co/docs/transformers/en/llm_optims/#llm-inference-optimization | #llm-inference-optimization | .md | 18_1 |
During decoding, a LLM computes the key-value (kv) values for each input token and since it is autoregressive, it computes the same kv values each time because the generated output becomes part of the input now. This is not very efficient because you're recomputing the same kv values each time.
To optimize this, you ... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_optims.md | https://huggingface.co/docs/transformers/en/llm_optims/#static-kv-cache-and-torchcompile | #static-kv-cache-and-torchcompile | .md | 18_2 |
> [!TIP]
> For a more in-depth explanation, take a look at the [Assisted Generation: a new direction toward low-latency text generation](https://hf.co/blog/assisted-generation) blog post!
Another issue with autoregression is that for each input token you need to load the model weights each time during the forward pas... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_optims.md | https://huggingface.co/docs/transformers/en/llm_optims/#speculative-decoding | #speculative-decoding | .md | 18_3 |
Prompt lookup decoding is a variant of speculative decoding that is also compatible with greedy search and sampling. Prompt lookup works especially well for input-grounded tasks - such as summarization - where there is often overlapping words between the prompt and output. These overlapping n-grams are used as the LLM ... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_optims.md | https://huggingface.co/docs/transformers/en/llm_optims/#prompt-lookup-decoding | #prompt-lookup-decoding | .md | 18_4 |
A known issue with transformer models is that the self-attention mechanism grows quadratically in compute and memory with the number of input tokens. This limitation is only magnified in LLMs which handles much longer sequences. To address this, try FlashAttention2 or PyTorch's scaled dot product attention (SDPA), whic... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_optims.md | https://huggingface.co/docs/transformers/en/llm_optims/#attention-optimizations | #attention-optimizations | .md | 18_5 |
FlashAttention and [FlashAttention-2](./perf_infer_gpu_one#flashattention-2) break up the attention computation into smaller chunks and reduces the number of intermediate read/write operations to GPU memory to speed up inference. FlashAttention-2 improves on the original FlashAttention algorithm by also parallelizing o... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_optims.md | https://huggingface.co/docs/transformers/en/llm_optims/#flashattention-2 | #flashattention-2 | .md | 18_6 |
In addition to optimizing inference, you can also enhance the training efficiency of large language models by leveraging torch.compile during fine-tuning and using a padding-free data collator. This approach can significantly speed up training and reduce computational overhead.
Here's how you can fine-tune a Llama mo... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_optims.md | https://huggingface.co/docs/transformers/en/llm_optims/#fine-tuning-with-torchcompile-and-padding-free-data-collation | #fine-tuning-with-torchcompile-and-padding-free-data-collation | .md | 18_7 |
Scaled dot product attention (SDPA) is automatically enabled in PyTorch 2.0 and it supports FlashAttention, xFormers, and PyTorch's C++ implementation. SDPA chooses the most performant attention algorithm if you're using a CUDA backend. For other backends, SDPA defaults to the PyTorch C++ implementation.
> [!TIP]
> S... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_optims.md | https://huggingface.co/docs/transformers/en/llm_optims/#pytorch-scaled-dot-product-attention | #pytorch-scaled-dot-product-attention | .md | 18_8 |
Quantization reduces the size of the LLM weights by storing them in a lower precision. This translates to lower memory usage and makes loading LLMs for inference more accessible if you're constrained by your GPUs memory. If you aren't limited by your GPU, you don't necessarily need to quantize your model because it can... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_optims.md | https://huggingface.co/docs/transformers/en/llm_optims/#quantization | #quantization | .md | 18_9 |
<!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agr... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/ | .md | 19_0 | |
[[open-in-colab]]
LLMs, or Large Language Models, are the key component behind text generation. In a nutshell, they consist of large pretrained transformer models trained to predict the next word (or, more precisely, token) given some input text. Since they predict one token at a time, you need to do something more e... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#generation-with-llms | #generation-with-llms | .md | 19_1 |
A language model trained for [causal language modeling](tasks/language_modeling) takes a sequence of text tokens as input and returns the probability distribution for the next token.
<!-- [GIF 1 -- FWD PASS] -->
<figure class="image table text-center m-0 w-full">
<video
style="max-width: 90%; margin: auto;"
autoplay ... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#generate-text | #generate-text | .md | 19_2 |
There are many [generation strategies](generation_strategies), and sometimes the default values may not be appropriate for your use case. If your outputs aren't aligned with what you're expecting, we've created a list of the most common pitfalls and how to avoid them.
```py
>>> from transformers import AutoModelForCa... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#common-pitfalls | #common-pitfalls | .md | 19_3 |
If not specified in the [`~generation.GenerationConfig`] file, `generate` returns up to 20 tokens by default. We highly recommend manually setting `max_new_tokens` in your `generate` call to control the maximum number of new tokens it can return. Keep in mind LLMs (more precisely, [decoder-only models](https://huggingf... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#generated-output-is-too-shortlong | #generated-output-is-too-shortlong | .md | 19_4 |
By default, and unless specified in the [`~generation.GenerationConfig`] file, `generate` selects the most likely token at each iteration (greedy decoding). Depending on your task, this may be undesirable; creative tasks like chatbots or writing an essay benefit from sampling. On the other hand, input-grounded tasks li... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#incorrect-generation-mode | #incorrect-generation-mode | .md | 19_5 |
LLMs are [decoder-only](https://huggingface.co/learn/nlp-course/chapter1/6?fw=pt) architectures, meaning they continue to iterate on your input prompt. If your inputs do not have the same length, they need to be padded. Since LLMs are not trained to continue from pad tokens, your input needs to be left-padded. Make sur... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#wrong-padding-side | #wrong-padding-side | .md | 19_6 |
Some models and tasks expect a certain input prompt format to work properly. When this format is not applied, you will get a silent performance degradation: the model kinda works, but not as well as if you were following the expected prompt. More information about prompting, including which models and tasks need to be ... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#wrong-prompt | #wrong-prompt | .md | 19_7 |
While the autoregressive generation process is relatively straightforward, making the most out of your LLM can be a challenging endeavor because there are many moving parts. For your next steps to help you dive deeper into LLM usage and understanding: | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#further-resources | #further-resources | .md | 19_8 |
1. Guide on how to [control different generation methods](generation_strategies), how to set up the generation configuration file, and how to stream the output;
2. [Accelerating text generation](llm_optims);
3. [Prompt templates for chat LLMs](chat_templating);
4. [Prompt design guide](tasks/prompting);
5. API referenc... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#advanced-generate-usage | #advanced-generate-usage | .md | 19_9 |
1. [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard), which focuses on the quality of the open-source models;
2. [Open LLM-Perf Leaderboard](https://huggingface.co/spaces/optimum/llm-perf-leaderboard), which focuses on LLM throughput. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#llm-leaderboards | #llm-leaderboards | .md | 19_10 |
1. Guide on how to [optimize LLMs for speed and memory](llm_tutorial_optimization);
2. Guide on [quantization](main_classes/quantization) such as bitsandbytes and autogptq, which shows you how to drastically reduce your memory requirements. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#latency-throughput-and-memory-utilization | #latency-throughput-and-memory-utilization | .md | 19_11 |
1. [`optimum`](https://github.com/huggingface/optimum), an extension of 🤗 Transformers that optimizes for specific hardware devices;
2. [`outlines`](https://github.com/outlines-dev/outlines), a library where you can constrain text generation (e.g. to generate JSON files);
3. [`SynCode`](https://github.com/uiuc-focal-l... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/llm_tutorial.md | https://huggingface.co/docs/transformers/en/llm_tutorial/#related-libraries | #related-libraries | .md | 19_12 |
<!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agr... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/ | .md | 20_0 | |
<Tip>
This is the very beginning of our experiments with TorchScript and we are still
exploring its capabilities with variable-input-size models. It is a focus of interest to
us and we will deepen our analysis in upcoming releases, with more code examples, a more
flexible implementation, and benchmarks comparing Pyth... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#export-to-torchscript | #export-to-torchscript | .md | 20_1 |
The `torchscript` flag is necessary because most of the 🤗 Transformers language models
have tied weights between their `Embedding` layer and their `Decoding` layer.
TorchScript does not allow you to export models that have tied weights, so it is
necessary to untie and clone the weights beforehand.
Models instantiate... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#torchscript-flag-and-tied-weights | #torchscript-flag-and-tied-weights | .md | 20_2 |
The dummy inputs are used for a models forward pass. While the inputs' values are
propagated through the layers, PyTorch keeps track of the different operations executed
on each tensor. These recorded operations are then used to create the *trace* of the
model.
The trace is created relative to the inputs' dimensions.... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#dummy-inputs-and-standard-lengths | #dummy-inputs-and-standard-lengths | .md | 20_3 |
This section demonstrates how to save and load models as well as how to use the trace
for inference. | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#using-torchscript-in-python | #using-torchscript-in-python | .md | 20_4 |
To export a `BertModel` with TorchScript, instantiate `BertModel` from the `BertConfig`
class and then save it to disk under the filename `traced_bert.pt`:
```python
from transformers import BertModel, BertTokenizer, BertConfig
import torch
enc = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
# Toke... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#saving-a-model | #saving-a-model | .md | 20_5 |
Now you can load the previously saved `BertModel`, `traced_bert.pt`, from disk and use
it on the previously initialised `dummy_input`:
```python
loaded_model = torch.jit.load("traced_bert.pt")
loaded_model.eval()
all_encoder_layers, pooled_output = loaded_model(*dummy_input)
``` | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#loading-a-model | #loading-a-model | .md | 20_6 |
Use the traced model for inference by using its `__call__` dunder method:
```python
traced_model(tokens_tensor, segments_tensors)
``` | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#using-a-traced-model-for-inference | #using-a-traced-model-for-inference | .md | 20_7 |
AWS introduced the [Amazon EC2 Inf1](https://aws.amazon.com/ec2/instance-types/inf1/)
instance family for low cost, high performance machine learning inference in the cloud.
The Inf1 instances are powered by the AWS Inferentia chip, a custom-built hardware
accelerator, specializing in deep learning inferencing workload... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#deploy-hugging-face-torchscript-models-to-aws-with-the-neuron-sdk | #deploy-hugging-face-torchscript-models-to-aws-with-the-neuron-sdk | .md | 20_8 |
Transformers models based on the [BERT (Bidirectional Encoder Representations from
Transformers)](https://huggingface.co/docs/transformers/main/model_doc/bert)
architecture, or its variants such as
[distilBERT](https://huggingface.co/docs/transformers/main/model_doc/distilbert) and
[roBERTa](https://huggingface.co/docs... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#implications | #implications | .md | 20_9 |
Using AWS Neuron to convert models requires a [Neuron SDK
environment](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html#installation-guide)
which comes preconfigured on [AWS Deep Learning
AMI](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-infe... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#dependencies | #dependencies | .md | 20_10 |
Convert a model for AWS NEURON using the same code from [Using TorchScript in
Python](torchscript#using-torchscript-in-python) to trace a `BertModel`. Import the
`torch.neuron` framework extension to access the components of the Neuron SDK through a
Python API:
```python
from transformers import BertModel, BertTokeni... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/torchscript.md | https://huggingface.co/docs/transformers/en/torchscript/#converting-a-model-for-aws-neuron | #converting-a-model-for-aws-neuron | .md | 20_11 |
<!--Copyright 2024 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agr... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/how_to_hack_models.md | https://huggingface.co/docs/transformers/en/how_to_hack_models/ | .md | 21_0 | |
The [🤗 Transformers](https://github.com/huggingface/transformers) library offers a collection of pre-trained models and tools for natural language processing, vision, and beyond. While these models cover a wide range of applications, you might encounter use cases that aren't supported out of the box. Customizing model... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/how_to_hack_models.md | https://huggingface.co/docs/transformers/en/how_to_hack_models/#how-to-hack-any-transformers-model | #how-to-hack-any-transformers-model | .md | 21_1 |
The **Segment Anything Model (SAM)** is a state-of-the-art model for image segmentation. In its default implementation, SAM uses a combined query-key-value (`qkv`) projection in its attention mechanism. However, you might want to fine-tune only specific components of the attention mechanism, such as the query (`q`) and... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/how_to_hack_models.md | https://huggingface.co/docs/transformers/en/how_to_hack_models/#example-modifying-the-attention-mechanism-in-the-segment-anything-model-sam | #example-modifying-the-attention-mechanism-in-the-segment-anything-model-sam | .md | 21_2 |
By splitting the combined `qkv` projection into separate `q`, `k`, and `v` projections, you can apply techniques like **LoRA** (Low-Rank Adaptation) to only the `q` and `v` projections. This approach allows you to:
- Fine-tune fewer parameters, reducing computational overhead.
- Potentially achieve better performance... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/how_to_hack_models.md | https://huggingface.co/docs/transformers/en/how_to_hack_models/#motivation | #motivation | .md | 21_3 |
Next, subclass the original `SamVisionAttention` class and modify it to have separate `q`, `k`, and `v` projections.
```python
import torch
import torch.nn as nn
from transformers.models.sam.modeling_sam import SamVisionAttention
class SamVisionAttentionSplit(SamVisionAttention, nn.Module):
def __init__(self, config... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/how_to_hack_models.md | https://huggingface.co/docs/transformers/en/how_to_hack_models/#step-1-create-a-custom-attention-class | #step-1-create-a-custom-attention-class | .md | 21_4 |
Replace the original `SamVisionAttention` class with your custom class so that the model uses the modified attention mechanism.
```python
from transformers import SamModel
from transformers.models.sam import modeling_sam
# Replace the attention class in the modeling_sam module
modeling_sam.SamVisionAttention = SamVi... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/how_to_hack_models.md | https://huggingface.co/docs/transformers/en/how_to_hack_models/#step-2-replace-the-original-attention-class | #step-2-replace-the-original-attention-class | .md | 21_5 |
With separate `q`, `k`, and `v` projections, you can now apply LoRA to specific components, such as the `q` and `v` projections.
```python
from peft import LoraConfig, get_peft_model
config = LoraConfig(
r=16,
lora_alpha=32,
target_modules=["q", "v"], # Apply LoRA to q and v projections
lora_dropout=0.1,
task_type=... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/how_to_hack_models.md | https://huggingface.co/docs/transformers/en/how_to_hack_models/#step-3-apply-lora-to-specific-projections | #step-3-apply-lora-to-specific-projections | .md | 21_6 |
It's simple to verify the number of trainable parameters and see what impact your modification had.
```python
model.print_trainable_parameters()
```
**Expected Output:**
```
trainable params: 608,256 || all params: 94,343,728 || trainable%: 0.6447
trainable params: 912,384 || all params: 94,647,856 || trainable%:... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/how_to_hack_models.md | https://huggingface.co/docs/transformers/en/how_to_hack_models/#step-4-verify-the-number-of-trainable-parameters | #step-4-verify-the-number-of-trainable-parameters | .md | 21_7 |
Modifying pre-trained models can open up new avenues for research and application. By understanding and adjusting the internal mechanisms of models like SAM, you can tailor them to your specific needs, optimize performance, and experiment with new ideas.
If you've developed your own hacks for Transformers models and ... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/how_to_hack_models.md | https://huggingface.co/docs/transformers/en/how_to_hack_models/#contributing-your-own-hacks | #contributing-your-own-hacks | .md | 21_8 |
<!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agr... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/ | .md | 22_0 | |
<Tip>
If you don't need long explanations and just want TPU code samples to get started with, check out [our TPU example notebook!](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/tpu_training-tf.ipynb)
</Tip> | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#training-on-tpu-with-tensorflow | #training-on-tpu-with-tensorflow | .md | 22_1 |
A TPU is a **Tensor Processing Unit.** They are hardware designed by Google, which are used to greatly speed up the tensor computations within neural networks, much like GPUs. They can be used for both network training and inference. They are generally accessed through Google’s cloud services, but small TPUs can also b... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#what-is-a-tpu | #what-is-a-tpu | .md | 22_2 |
New users are often very confused by the range of TPUs, and the different ways to access them. The first key distinction to understand is the difference between **TPU Nodes** and **TPU VMs.**
When you use a **TPU Node**, you are effectively indirectly accessing a remote TPU. You will need a separate VM, which will in... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#what-kinds-of-tpu-are-available | #what-kinds-of-tpu-are-available | .md | 22_3 |
A single TPU (a v2-8/v3-8/v4-8) runs 8 replicas. TPUs exist in **pods** that can run hundreds or thousands of replicas simultaneously. When you use more than a single TPU but less than a whole pod (for example, a v3-32), your TPU fleet is referred to as a **pod slice.**
When you access a free TPU via Colab, you gener... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#what-sizes-of-tpu-are-available | #what-sizes-of-tpu-are-available | .md | 22_4 |
XLA is an optimizing compiler, used by both TensorFlow and JAX. In JAX it is the only compiler, whereas in TensorFlow it is optional (but mandatory on TPU!). The easiest way to enable it when training a Keras model is to pass the argument `jit_compile=True` to `model.compile()`. If you don’t get any errors and performa... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#i-keep-hearing-about-this-xla-thing-whats-xla-and-how-does-it-relate-to-tpus | #i-keep-hearing-about-this-xla-thing-whats-xla-and-how-does-it-relate-to-tpus | .md | 22_5 |
In many cases, your code is probably XLA-compatible already! However, there are a few things that work in normal TensorFlow that don’t work in XLA. We’ve distilled them into three core rules below:
<Tip>
**🤗Specific HuggingFace Tip🤗:** We’ve put a lot of effort into rewriting our TensorFlow models and loss functi... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#how-do-i-make-my-model-xla-compatible | #how-do-i-make-my-model-xla-compatible | .md | 22_6 |
What that means is that any `if` statement cannot depend on values inside a `tf.Tensor`. For example, this code block cannot be compiled with XLA!
```python
if tf.reduce_sum(tensor) > 10:
tensor = tensor / 2.0
```
This might seem very restrictive at first, but most neural net code doesn’t need to do this. You can o... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#xla-rule-1-your-code-cannot-have-data-dependent-conditionals | #xla-rule-1-your-code-cannot-have-data-dependent-conditionals | .md | 22_7 |
What this means is that the shape of all of the `tf.Tensor` objects in your code cannot depend on their values. For example, the function `tf.unique` cannot be compiled with XLA, because it returns a `tensor` containing one instance of each unique value in the input. The shape of this output will obviously be different... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#xla-rule-2-your-code-cannot-have-data-dependent-shapes | #xla-rule-2-your-code-cannot-have-data-dependent-shapes | .md | 22_8 |
This is the big one. What this means is that if your input shapes are very variable, XLA will have to recompile your model over and over, which will create huge performance problems. This commonly arises in NLP models, where input texts have variable lengths after tokenization. In other modalities, static shapes are mo... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#xla-rule-3-xla-will-need-to-recompile-your-model-for-every-different-input-shape-it-sees | #xla-rule-3-xla-will-need-to-recompile-your-model-for-every-different-input-shape-it-sees | .md | 22_9 |
Once your training is XLA-compatible and (if you’re using TPU Node / Colab) your dataset has been prepared appropriately, running on TPU is surprisingly easy! All you really need to change in your code is to add a few lines to initialize your TPU, and to ensure that your model and dataset are created inside a `TPUStrat... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#how-do-i-actually-train-my-model-on-tpu | #how-do-i-actually-train-my-model-on-tpu | .md | 22_10 |
There was a lot in here, so let’s summarize with a quick checklist you can follow when you want to get your model ready for TPU training:
- Make sure your code follows the three rules of XLA
- Compile your model with `jit_compile=True` on CPU/GPU and confirm that you can train it with XLA
- Either load your dataset i... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/perf_train_tpu_tf.md | https://huggingface.co/docs/transformers/en/perf_train_tpu_tf/#summary | #summary | .md | 22_11 |
<!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agr... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/ | .md | 23_0 | |
[[open-in-colab]]
Get up and running with 🤗 Transformers! Whether you're a developer or an everyday user, this quick tour will help you get started and show you how to use the [`pipeline`] for inference, load a pretrained model and preprocessor with an [AutoClass](./model_doc/auto), and quickly train a model with Py... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#quick-tour | #quick-tour | .md | 23_1 |
<Youtube id="tiZFewofSLM"/>
The [`pipeline`] is the easiest and fastest way to use a pretrained model for inference. You can use the [`pipeline`] out-of-the-box for many tasks across different modalities, some of which are shown in the table below:
<Tip>
For a complete list of available tasks, check out the [pipe... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#pipeline | #pipeline | .md | 23_2 |
The [`pipeline`] can accommodate any model from the [Hub](https://huggingface.co/models), making it easy to adapt the [`pipeline`] for other use-cases. For example, if you'd like a model capable of handling French text, use the tags on the Hub to filter for an appropriate model. The top filtered result returns a multil... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#use-another-model-and-tokenizer-in-the-pipeline | #use-another-model-and-tokenizer-in-the-pipeline | .md | 23_3 |
<Youtube id="AhChOFRegn4"/>
Under the hood, the [`AutoModelForSequenceClassification`] and [`AutoTokenizer`] classes work together to power the [`pipeline`] you used above. An [AutoClass](./model_doc/auto) is a shortcut that automatically retrieves the architecture of a pretrained model from its name or path. You onl... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#autoclass | #autoclass | .md | 23_4 |
A tokenizer is responsible for preprocessing text into an array of numbers as inputs to a model. There are multiple rules that govern the tokenization process, including how to split a word and at what level words should be split (learn more about tokenization in the [tokenizer summary](./tokenizer_summary)). The most ... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#autotokenizer | #autotokenizer | .md | 23_5 |
<frameworkcontent>
<pt>
🤗 Transformers provides a simple and unified way to load pretrained instances. This means you can load an [`AutoModel`] like you would load an [`AutoTokenizer`]. The only difference is selecting the correct [`AutoModel`] for the task. For text (or sequence) classification, you should load [`Aut... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#automodel | #automodel | .md | 23_6 |
<frameworkcontent>
<pt>
Once your model is fine-tuned, you can save it with its tokenizer using [`PreTrainedModel.save_pretrained`]:
```py
>>> pt_save_directory = "./pt_save_pretrained"
>>> tokenizer.save_pretrained(pt_save_directory) # doctest: +IGNORE_RESULT
>>> pt_model.save_pretrained(pt_save_directory)
```
Wh... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#save-a-model | #save-a-model | .md | 23_7 |
You can modify the model's configuration class to change how a model is built. The configuration specifies a model's attributes, such as the number of hidden layers or attention heads. You start from scratch when you initialize a model from a custom configuration class. The model attributes are randomly initialized, an... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#custom-model-builds | #custom-model-builds | .md | 23_8 |
All models are a standard [`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) so you can use them in any typical training loop. While you can write your own training loop, 🤗 Transformers provides a [`Trainer`] class for PyTorch, which contains the basic training loop and adds additional functi... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#trainer---a-pytorch-optimized-training-loop | #trainer---a-pytorch-optimized-training-loop | .md | 23_9 |
All models are a standard [`tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model) so they can be trained in TensorFlow with the [Keras](https://keras.io/) API. 🤗 Transformers provides the [`~TFPreTrainedModel.prepare_tf_dataset`] method to easily load your dataset as a `tf.data.Dataset` so you ca... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#train-with-tensorflow | #train-with-tensorflow | .md | 23_10 |
Now that you've completed the 🤗 Transformers quick tour, check out our guides and learn how to do more specific things like writing a custom model, fine-tuning a model for a task, and how to train a model with a script. If you're interested in learning more about 🤗 Transformers core concepts, grab a cup of coffee and... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/quicktour.md | https://huggingface.co/docs/transformers/en/quicktour/#whats-next | #whats-next | .md | 23_11 |
<!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agr... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/trainer.md | https://huggingface.co/docs/transformers/en/trainer/ | .md | 24_0 | |
The [`Trainer`] is a complete training and evaluation loop for PyTorch models implemented in the Transformers library. You only need to pass it the necessary pieces for training (model, tokenizer, dataset, evaluation function, training hyperparameters, etc.), and the [`Trainer`] class takes care of the rest. This makes... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/trainer.md | https://huggingface.co/docs/transformers/en/trainer/#trainer | #trainer | .md | 24_1 |
[`Trainer`] includes all the code you'll find in a basic training loop:
1. perform a training step to calculate the loss
2. calculate the gradients with the [`~accelerate.Accelerator.backward`] method
3. update the weights based on the gradients
4. repeat this process until you've reached a predetermined number of ep... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/trainer.md | https://huggingface.co/docs/transformers/en/trainer/#basic-usage | #basic-usage | .md | 24_2 |
The [`Trainer`] class saves your model checkpoints to the directory specified in the `output_dir` parameter of [`TrainingArguments`]. You'll find the checkpoints saved in a `checkpoint-000` subfolder where the numbers at the end correspond to the training step. Saving checkpoints are useful for resuming training later.... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/trainer.md | https://huggingface.co/docs/transformers/en/trainer/#checkpoints | #checkpoints | .md | 24_3 |
While the [`Trainer`] class is designed to be accessible and easy-to-use, it also offers a lot of customizability for more adventurous users. Many of the [`Trainer`]'s method can be subclassed and overridden to support the functionality you want, without having to rewrite the entire training loop from scratch to accomm... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/trainer.md | https://huggingface.co/docs/transformers/en/trainer/#customize-the-trainer | #customize-the-trainer | .md | 24_4 |
Another option for customizing the [`Trainer`] is to use [callbacks](callbacks). Callbacks *don't change* anything in the training loop. They inspect the training loop state and then execute some action (early stopping, logging results, etc.) depending on the state. In other words, a callback can't be used to implement... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/trainer.md | https://huggingface.co/docs/transformers/en/trainer/#callbacks | #callbacks | .md | 24_5 |
<Tip>
Check out the [logging](./main_classes/logging) API reference for more information about the different logging levels.
</Tip>
The [`Trainer`] is set to `logging.INFO` by default which reports errors, warnings, and other basic information. A [`Trainer`] replica - in distributed environments - is set to `logg... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/trainer.md | https://huggingface.co/docs/transformers/en/trainer/#logging | #logging | .md | 24_6 |
[NEFTune](https://hf.co/papers/2310.05914) is a technique that can improve performance by adding noise to the embedding vectors during training. To enable it in [`Trainer`], set the `neftune_noise_alpha` parameter in [`TrainingArguments`] to control how much noise is added.
```py
from transformers import TrainingArgu... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/trainer.md | https://huggingface.co/docs/transformers/en/trainer/#neftune | #neftune | .md | 24_7 |
[Liger-Kernel](https://github.com/linkedin/Liger-Kernel) Kernel is a collection of Triton kernels developed by Linkedin designed specifically for LLM training. We have implemented Hugging Face Compatible RMSNorm, RoPE, SwiGLU, CrossEntropy, FusedLinearCrossEntropy, and more to come. It can effectively increase multi-GP... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/trainer.md | https://huggingface.co/docs/transformers/en/trainer/#liger-kernel | #liger-kernel | .md | 24_8 |
You can choose a built-in optimizer for training using:
```python
from transformers import TrainingArguments
training_args = TrainingArguments(..., optim="adamw_torch")
```
See [`OptimizerNames`](https://github.com/huggingface/transformers/blob/main/src/transformers/training_args.py) for a full list of choices. We ... | /Users/nielsrogge/Documents/python_projecten/transformers/docs/source/en/trainer.md | https://huggingface.co/docs/transformers/en/trainer/#optimizers | #optimizers | .md | 24_9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.