vector listlengths 1.02k 1.02k | text stringlengths 2 11.8k |
|---|---|
[
-0.043179467,
-0.014780203,
-0.01791903,
0.030099776,
-0.017589416,
0.0047082403,
-0.034369778,
-0.017634364,
0.022129104,
0.056334075,
0.0016031238,
0.0119635,
0.042250555,
-0.021994261,
-0.006165285,
0.07173605,
0.011161937,
-0.00990341,
-0.030399425,
-0.027208159,
0.053307... | FlashAttention can only be used for models with the fp16 or bf16 torch type, so make sure to cast your model to the appropriate type first. The memory-efficient attention backend is able to handle fp32 models.
By default, SDPA selects the most performant kernel available but you can check whether a backend is availabl... |
[
-0.0048741302,
0.005925342,
-0.011450568,
0.04396902,
0.005670723,
-0.019758414,
-0.0089553045,
-0.008089601,
-0.016164653,
0.05118564,
0.004979615,
0.016193751,
0.04100089,
-0.0611085,
-0.018099755,
0.02278474,
0.018434396,
-0.038440157,
-0.049847074,
-0.010613964,
0.0355593... | with torch.backends.cuda.sdp_kernel(enable_flash=True, enable_math=False, enable_mem_efficient=False):
outputs = model.generate(**inputs)
print(tokenizer.decode(outputs[0], skip_special_tokens=True)) |
[
0.019099504,
-0.012807478,
-0.0060649933,
0.002037881,
-0.025845593,
0.0032343029,
0.0072037564,
0.007841608,
0.005301013,
0.040476535,
0.015380506,
-0.01725442,
0.034883622,
-0.050566837,
0.004270361,
0.038862083,
-0.021852715,
-0.04062068,
-0.0488659,
-0.012461525,
0.017441... | import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", torch_dtype=torch.float16).to("cuda")
convert the model to BetterTransformer
model.to_bettertransformer()
input_text ... |
[
0.05908903,
-0.0034124202,
-0.08093996,
0.0027170659,
0.008444355,
-0.0020288615,
-0.008122597,
-0.014929562,
0.012441301,
0.041070595,
0.047305547,
0.0010501817,
0.053855103,
-0.05030862,
-0.006656811,
0.029973526,
-0.012684407,
-0.015458674,
-0.02810018,
0.03389182,
0.01907... | Check out our benchmarks with BetterTransformer and scaled dot product attention in the Out of the box acceleration and memory savings of 🤗 decoder models with PyTorch 2.0 and learn more about the fastpath execution in the BetterTransformer blog post.
BetterTransformer accelerates inference with its fastpath (native ... |
[
-0.0034627263,
-0.0022612652,
-0.05277335,
0.026204793,
-0.0092759095,
-0.047037113,
-0.012067077,
0.0011796005,
-0.009142997,
0.046505462,
0.007145808,
0.0126756765,
0.036040336,
-0.04451877,
-0.019769019,
0.0050157066,
0.00068205217,
-0.036152262,
-0.02354654,
-0.022930942,
... | print(tokenizer.decode(outputs[0], skip_special_tokens=True))
If you see a bug with the traceback below, try using the nightly version of PyTorch which may have broader coverage for FlashAttention:
```bash
RuntimeError: No available kernel. Aborting execution.
install PyTorch nightly
pip3 install -U --pre torch torchv... |
[
0.02594011,
0.005701284,
-0.037182286,
-0.0035833516,
0.017745428,
0.025415186,
0.0073817773,
-0.02806898,
0.007108378,
0.030358242,
-0.002580888,
0.029177157,
0.05170525,
-0.0342077,
-0.007028181,
0.040652633,
-0.0028360605,
0.01969932,
-0.03190386,
-0.0003561024,
-0.0014417... | BetterTransformer
Some BetterTransformer features are being upstreamed to Transformers with default support for native torch.nn.scaled_dot_product_attention. BetterTransformer still has a wider coverage than the Transformers SDPA integration, but you can expect more and more architectures to natively support SDPA in T... |
[
0.04524428,
0.018462077,
-0.06288869,
0.02531901,
-0.00717611,
-0.015019265,
0.004611933,
-0.017587028,
0.0017205091,
0.03669463,
0.05083885,
0.0025408666,
0.043178596,
-0.06529866,
-0.015664792,
0.03669463,
-0.0043035145,
-0.0015842313,
-0.0102567095,
0.037354507,
0.02135977... | BetterTransformer accelerates inference with its fastpath (native PyTorch specialized implementation of Transformer functions) execution. The two optimizations in the fastpath execution are:
fusion, which combines multiple sequential operations into a single "kernel" to reduce the number of computation steps
skipping ... |
[
0.023651417,
0.0062014665,
-0.037741624,
-0.023917828,
-0.01347598,
-0.027366377,
0.019137222,
-0.011063476,
-0.025901115,
0.022437764,
-0.004769505,
-0.0278992,
0.043869086,
-0.023029791,
0.0022940987,
0.03276861,
0.012846952,
-0.025531098,
-0.038244843,
0.0007557575,
0.0096... |
BetterTransformer also converts all attention operations to use the more memory-efficient scaled dot product attention (SDPA), and it calls optimized kernels like FlashAttention under the hood.
Before you start, make sure you have 🤗 Optimum installed.
Then you can enable BetterTransformer with the [PreTrainedModel.t... |
[
0.05069706,
-0.014916689,
-0.005792343,
-0.020624677,
-0.043779988,
-0.009349291,
0.027541747,
0.0040771347,
-0.022016527,
0.066640064,
0.011500332,
-0.039224844,
0.013222569,
-0.019710837,
0.009960862,
0.060397826,
0.008477628,
-0.05348076,
-0.03514771,
0.0009788638,
0.00850... | To load a model in 4-bit for inference with multiple GPUs, you can control how much GPU RAM you want to allocate to each GPU. For example, to distribute 600MB of memory to the first GPU and 1GB of memory to the second GPU:
py
max_memory_mapping = {0: "600MB", 1: "1GB"}
model_name = "bigscience/bloom-3b"
model_4bit = Au... |
[
0.009225643,
0.0037907346,
-0.014263561,
-0.034373075,
-0.00076280185,
-0.016835216,
0.032321367,
-0.026124097,
-0.012246989,
0.03358612,
0.003427119,
-0.010497418,
-0.0023432993,
-0.050421335,
0.030916091,
0.020882415,
0.02998861,
-0.06486758,
-0.0074128355,
0.007820366,
-0.... | If you're curious and interested in learning more about the concepts underlying 8-bit quantization, read the Gentle Introduction to 8-bit Matrix Multiplication for transformers at scale using Hugging Face Transformers, Accelerate and bitsandbytes blog post. |
[
0.031658463,
-0.0096143,
-0.013094958,
-0.03328425,
-0.04386663,
0.01813489,
0.015459736,
-0.032781735,
-0.016509106,
0.06715969,
0.04197481,
-0.051463477,
0.02250973,
-0.03742261,
0.028732052,
0.047768515,
0.014580334,
-0.03097859,
-0.028022619,
-0.0033993681,
0.017794954,
... | To load a model in 8-bit for inference, use the load_in_8bit parameter. The device_map parameter is optional, but we recommend setting it to "auto" to allow 🤗 Accelerate to automatically and efficiently allocate the model given the available resources in the environment:
from transformers import AutoModelForCausalLM
... |
[
0.0456225,
-0.01291596,
-0.0047393236,
-0.024701027,
-0.05523507,
0.02065363,
0.023227895,
-0.031545892,
-0.021963082,
0.051812638,
0.04898541,
-0.048390206,
0.029581713,
-0.03794435,
0.016606234,
0.059193186,
0.021546438,
-0.03151613,
-0.05211024,
0.0217994,
0.010252414,
-... | 4-bit
To load a model in 4-bit for inference, use the load_in_4bit parameter. The device_map parameter is optional, but we recommend setting it to "auto" to allow 🤗 Accelerate to automatically and efficiently allocate the model given the available resources in the environment.
from transformers import AutoModelForCau... |
[
0.051034555,
-0.016927024,
-0.0055132527,
-0.021377057,
-0.048330735,
-0.009723885,
0.023742896,
0.0065060607,
-0.018335262,
0.06742644,
0.014617513,
-0.045063622,
0.014138712,
-0.023968214,
0.010864558,
0.05880803,
0.0068616406,
-0.05373837,
-0.032417644,
0.00090479304,
0.00... | To load a model in 4-bit for inference with multiple GPUs, you can control how much GPU RAM you want to allocate to each GPU. For example, to distribute 1GB of memory to the first GPU and 2GB of memory to the second GPU:
py
max_memory_mapping = {0: "1GB", 1: "2GB"}
model_name = "bigscience/bloom-3b"
model_8bit = AutoMo... |
[
0.027712787,
-0.005090826,
-0.02111383,
-0.0056962026,
0.020561557,
-0.014500712,
0.009912596,
-0.023733588,
0.009855953,
0.052338507,
0.009006302,
-0.019372044,
0.020165052,
-0.05686998,
0.009438207,
0.03908395,
0.010663121,
-0.021127991,
-0.052735012,
0.009353243,
-0.003752... |
ONNX Runtime (ORT) is a model accelerator that supports accelerated inference on Nvidia GPUs, and AMD GPUs that use ROCm stack. ORT uses optimization techniques like fusing common operations into a single node and constant folding to reduce the number of computations performed and speedup inference. ORT also places t... |
[
0.030968545,
-0.009188309,
0.0066867224,
0.0010289373,
-0.0064420416,
-0.04031754,
0.032254033,
-0.023810722,
-0.0022806434,
0.06333944,
0.0073696375,
-0.043911062,
0.03187423,
-0.04052205,
-0.007603362,
0.015192117,
0.024599543,
-0.028529042,
-0.028426787,
-0.011321048,
0.01... | If you're loading a model in 8-bit for text generation, you should use the [~transformers.GenerationMixin.generate] method instead of the [Pipeline] function which is not optimized for 8-bit models and will be slower. Some sampling strategies, like nucleus sampling, are also not supported by the [Pipeline] for 8-bit mo... |
[
0.00918041,
-0.021624032,
0.0063023414,
0.00013031403,
-0.014537401,
0.016568154,
-0.024271015,
-0.019397205,
0.008515163,
0.06341556,
0.021385944,
-0.03319233,
0.025937635,
-0.033556465,
-0.006950082,
0.031539716,
-0.025937635,
-0.040671106,
-0.04285592,
-0.0066349646,
0.020... | from optimum.onnxruntime import ORTModelForSequenceClassification
ort_model = ORTModelForSequenceClassification.from_pretrained(
"distilbert/distilbert-base-uncased-finetuned-sst-2-english",
export=True,
provider="CUDAExecutionProvider",
)
Now you're free to use the model for inference: |
[
0.0076780287,
0.01666326,
0.006586298,
0.0045428933,
-0.029562924,
-0.016648896,
0.0013206712,
-0.0004798768,
-0.008087427,
0.032809388,
-0.0049666576,
-0.017352775,
0.010342713,
-0.05389703,
-0.009286895,
0.027135259,
-0.010005139,
-0.056137953,
-0.042836074,
-0.010450451,
-... | from transformers import AutoModelForCausalLM, AutoTokenizer
model_name = "bigscience/bloom-2b5"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model_8bit = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", load_in_8bit=True)
prompt = "Hello, my llama is cute"
inputs = tokenizer(prompt, return_... |
[
0.05767761,
-0.013860512,
-0.017786724,
0.0208746,
-0.038256127,
0.0029551394,
0.029174142,
-0.0017229579,
0.01837356,
0.026798852,
0.021433493,
-0.018136032,
-0.022844695,
-0.045549665,
0.0041218256,
0.015816633,
0.011939322,
-0.033365827,
-0.021684993,
0.00042921127,
0.0205... | Feel free to try running a 11 billion parameter T5 model or the 3 billion parameter BLOOM model for inference on Google Colab's free tier GPUs!
🤗 Optimum
Learn more details about using ORT with 🤗 Optimum in the Accelerated inference on NVIDIA GPUs and Accelerated inference on AMD GPUs guides. This section only prov... |
[
0.04151195,
0.0040114243,
-0.026989756,
-0.028275648,
-0.012970737,
-0.03368478,
0.0067299674,
0.015193094,
-0.009217889,
0.042769887,
0.044614863,
-0.023006286,
0.02461365,
-0.03757041,
0.017918626,
0.051938858,
0.016660688,
-0.03949925,
-0.021776302,
0.019707693,
0.01629728... | Combine optimizations
It is often possible to combine several of the optimization techniques described above to get the best inference performance possible for your model. For example, you can load a model in 4-bit, and then enable BetterTransformer with FlashAttention: |
[
0.018649248,
-0.020638693,
-0.012144196,
0.02696484,
-0.02427408,
-0.018520435,
-0.012401822,
-0.006437068,
0.008000714,
0.041535012,
0.010548348,
-0.045599774,
0.017690308,
-0.037785124,
0.0056033623,
0.034035236,
-0.046229526,
-0.038958754,
-0.05518918,
0.00685571,
0.001978... | Now you're free to use the model for inference:
from optimum.pipelines import pipeline
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased-finetuned-sst-2-english")
pipeline = pipeline(task="text-classification", model=ort_model, tokenizer=tokenizer, dev... |
[
0.016339218,
-0.021480825,
-0.046439353,
0.043351393,
-0.005804919,
-0.0056999885,
-0.010837848,
-0.047728505,
0.009983412,
0.06014031,
0.015514762,
0.0007106248,
-0.0041709975,
-0.056063004,
0.0016395431,
0.013723444,
-0.010815362,
-0.007097816,
-0.057502054,
-0.017133694,
0... |
Efficient Training on Multiple CPUs
When training on a single CPU is too slow, we can use multiple CPUs. This guide focuses on PyTorch-based DDP enabling
distributed CPU training efficiently on bare metal and Kubernetes.
Intel® oneCCL Bindings for PyTorch
Intel® oneCCL (collective communications library) is a library ... |
[
0.008724746,
-0.028522661,
-0.005380023,
0.024309732,
-0.0005942221,
0.009457738,
-0.011542853,
-0.003392759,
0.04497585,
0.031113042,
0.0070381514,
-0.007372624,
0.004561633,
-0.052803926,
0.009934539,
0.0698549,
0.017150601,
0.015869644,
-0.040478267,
0.015627686,
0.0351267... | pip install oneccl_bind_pt=={pytorch_version} -f https://developer.intel.com/ipex-whl-stable-cpu
where {pytorch_version} should be your PyTorch version, for instance 2.1.0.
Check more approaches for oneccl_bind_pt installation.
Versions of oneCCL and PyTorch must match.
oneccl_bindings_for_pytorch 1.12.0 prebuilt whee... |
[
0.004254851,
-0.028468821,
-0.026111156,
0.033950396,
0.010108494,
0.0056510316,
-0.014713312,
-0.04682915,
0.032535795,
0.03486399,
0.021101113,
-0.0047632228,
-0.0023281956,
-0.06212451,
0.022442037,
0.030708605,
0.016813109,
-0.0032546849,
-0.054462094,
-0.015192213,
0.031... | Intel® MPI library
Use this standards-based MPI implementation to deliver flexible, efficient, scalable cluster messaging on Intel® architecture. This component is part of the Intel® oneAPI HPC Toolkit.
oneccl_bindings_for_pytorch is installed along with the MPI tool set. Need to source the environment before using it.... |
[
0.019455273,
-0.020767847,
-0.017530164,
-0.00095799717,
-0.013745573,
0.007736898,
0.021365797,
0.0038064662,
-0.013709113,
0.034272783,
0.009333864,
-0.021497056,
0.030364227,
-0.048156902,
0.0027527607,
0.046085954,
-0.010624562,
-0.048769437,
-0.04246908,
0.005961276,
0.0... |
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
load model in 4-bit
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.float16
)
tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
model = AutoModelForCausalLM.from... |
[
0.041592438,
0.024176523,
-0.010545079,
0.03662486,
-0.021898491,
-0.008994549,
-0.00033826006,
-0.028923646,
0.0027226144,
0.03506698,
-0.0074587143,
0.002775891,
0.03686001,
-0.005963297,
-0.0072823507,
0.014888035,
0.015475914,
-0.040299103,
-0.048882134,
-0.022045461,
0.0... |
resources:
limits:
cpu: 200 # Update the CPU and memory limit values based on your nodes
memory: 128Gi
requests:
cpu: 200 # Update the CPU and memory request values based on your nodes
memory: 128Gi... |
[
-0.0097344015,
-0.02513821,
0.009050907,
0.021771101,
-0.045671828,
0.011180532,
0.016662879,
-0.026807377,
0.0075544138,
0.032721404,
0.018274486,
0.015238332,
0.013900121,
-0.06314051,
-0.0061550485,
0.01863422,
0.02158404,
0.013166264,
-0.034246676,
0.001648481,
0.01188561... | oneccl_bindings_for_pytorch_path=$(python -c "from oneccl_bindings_for_pytorch import cwd; print(cwd)")
source $oneccl_bindings_for_pytorch_path/env/setvars.sh
for Intel® oneCCL whose version < 1.12.0 |
[
0.04475908,
-0.003906653,
-0.0074365926,
0.06468301,
-0.0027015202,
-0.010478201,
0.021095926,
-0.014998756,
-0.03142065,
0.042694137,
0.013233786,
-0.030304465,
0.03931767,
-0.0424709,
-0.00040657967,
0.014468568,
-0.0066692145,
-0.054442,
-0.060832165,
-0.009292253,
0.00238... |
The CPU resource limits/requests in the yaml are defined in cpu units
where 1 CPU unit is equivalent to 1 physical CPU core or 1 virtual core (depending on whether the node is a physical
host or a VM). The amount of CPU and memory limits/requests defined in the yaml should be less than the amount of
available CPU/mem... |
[
0.026694428,
0.0022950224,
-0.017568657,
0.043300845,
-0.031195233,
0.0045318445,
-0.043393966,
-0.04143844,
0.0015442416,
0.075551435,
0.0033659034,
0.027284188,
0.01022769,
-0.04081764,
0.024195705,
0.03873796,
-0.007872528,
-0.043952685,
-0.04876389,
-0.008939529,
0.019694... |
torch_ccl_path=$(python -c "import torch; import torch_ccl; import os; print(os.path.abspath(os.path.dirname(torch_ccl.__file__)))")
source $torch_ccl_path/env/setvars.sh
Intel® Extension for PyTorch installation
Intel Extension for PyTorch (IPEX) provides performance optimizations for CPU training with both Float32... |
[
0.052616525,
0.013467989,
-0.0641107,
0.03130209,
-0.027228912,
-0.02215139,
0.002282444,
-0.010713015,
0.041261844,
0.021272587,
0.003965071,
-0.0026364059,
0.048403855,
-0.05599224,
0.0004413626,
0.016362457,
-0.0062248474,
-0.02671279,
-0.0147164455,
-0.014353765,
-0.01016... | Deploy
After the PyTorchJob spec has been updated with values appropriate for your cluster and training job, it can be deployed
to the cluster using: |
[
0.07049036,
0.0015687904,
-0.023849338,
0.015216801,
0.008252676,
-0.007947297,
-0.013094047,
0.010844671,
0.009719984,
0.032265875,
0.020393346,
-0.024594165,
0.05758997,
-0.019961346,
-0.014412389,
-0.004841371,
0.007813228,
-0.0060219206,
-0.046715505,
-0.022583134,
-0.001... |
The image needs to be built and copied to the cluster's nodes or pushed to a container registry prior to deploying the
PyTorchJob to the cluster.
PyTorchJob Specification File
The Kubeflow PyTorchJob is used to run the distributed
training job on the cluster. The yaml file for the PyTorchJob defines parameters such a... |
[
0.06188327,
0.019439362,
-0.041819353,
-0.0062488313,
0.008639717,
-0.0090821115,
0.017682793,
-0.007819984,
0.009615588,
0.03562582,
0.032268822,
0.03908691,
0.03801996,
-0.049079835,
-0.012224418,
0.013922435,
-0.0023632357,
-0.043250628,
-0.026296487,
-0.026986104,
0.00297... | transformers-pytorchjob-worker-0 1/1 Running 0 7m37s
transformers-pytorchjob-worker-1 1/1 Running 0 7m37s
transformers-pytorchjob-worker-2 1/1 Running 0 ... |
[
0.03335504,
0.0022067123,
-0.018863609,
0.024569439,
0.015330119,
-0.029092854,
0.012016614,
0.0094868,
0.033437535,
0.05978059,
0.010483602,
0.00012857451,
0.073694564,
-0.015440111,
-0.033547524,
-0.020760968,
0.019688549,
-0.06495021,
-0.019853536,
-0.020912208,
0.00454747... | The logs for worker can be viewed using kubectl logs -n kubeflow <pod name>. Add -f to stream the logs, for example: |
[
0.026192065,
-0.0066815754,
-0.052239742,
0.03139005,
0.0048803296,
-0.04409623,
-0.010634209,
-0.026986202,
0.036819056,
0.04813911,
0.014872011,
0.014648208,
0.042305816,
-0.071558915,
-0.015969362,
0.016720183,
-0.0029707924,
-0.019968923,
-0.05550292,
-0.035692826,
-0.003... |
kubectl logs -n kubeflow transformers-pytorchjob-worker-0 -f
After the training job completes, the trained model can be copied from the PVC or storage location. When you are done
with the job, the PyTorchJob resource can be deleted from the cluster using kubectl delete -f pytorchjob.yaml.
Summary
This guide covered r... |
[
0.059854526,
-0.024854101,
-0.042544376,
0.042251974,
0.032368813,
-0.03137465,
0.00981737,
0.008976717,
0.048187718,
0.033538416,
0.005084126,
-0.026038326,
0.060702488,
-0.02704711,
-0.035906866,
0.017777992,
-0.0052339816,
-0.016140547,
-0.03163781,
-0.015848145,
0.0054130... | kubectl create -f pytorchjob.yaml
The kubectl get pods -n kubeflow command can then be used to list the pods in the kubeflow namespace. You should see
the worker pods for the PyTorchJob that was just deployed. At first, they will probably have a status of "Pending" as
the containers get pulled and created, then the sta... |
[
0.030858645,
-0.00038721456,
-0.081082955,
-0.027496949,
-0.007535083,
-0.037811898,
-0.036633864,
0.01958116,
-0.00045792334,
0.046173036,
0.0007820612,
0.006852688,
0.00017856764,
-0.028617514,
0.023618069,
0.020716092,
-0.0034047945,
0.010034806,
0.0077721262,
-0.02703723,
... | Custom Tools and Prompts
If you are not aware of what tools and agents are in the context of transformers, we recommend you read the
Transformers Agents page first.
Transformers Agents is an experimental API that is subject to change at any time. Results returned by the agents
can vary as the APIs or underlying model... |
[
0.048000872,
-0.01867351,
-0.04700573,
0.009146508,
0.021644294,
-0.029078577,
-0.019551573,
0.0043647136,
-0.0284932,
0.03204936,
-0.019024735,
0.037698247,
-0.005297657,
-0.020356467,
-0.00416349,
0.01529296,
-0.018658875,
-0.038693383,
-0.035971384,
-0.012724621,
0.0188491... |
Customizing the prompt
As explained in Transformers Agents agents can run in [~Agent.run] and [~Agent.chat] mode.
Both the run and chat modes underlie the same logic. The language model powering the agent is conditioned on a long
prompt and completes the prompt by generating the next tokens until the stop token is r... |
[
0.04199164,
-0.016702836,
-0.04528956,
-0.011947858,
-0.007868102,
-0.03550952,
-0.027648523,
0.045545436,
0.006755764,
0.047819864,
-0.0017982202,
0.0154092545,
0.00014825987,
-0.0074558617,
0.032353748,
0.0028448128,
0.031955723,
-0.021934021,
-0.019233137,
0.0009897319,
-0... | Creating and using custom tools and prompts is paramount to empowering the agent and having it perform new tasks.
In this guide we'll take a look at:
How to customize the prompt
How to use custom tools
How to create custom tools |
[
0.026203873,
-0.012853627,
-0.0055942493,
-0.020580411,
-0.009954258,
-0.033244155,
-0.055475086,
0.029870078,
0.028102703,
0.055650365,
0.0271825,
0.015278289,
-0.0053094244,
0.011181195,
-0.0051341476,
0.023998307,
-0.026145447,
-0.04565959,
-0.030410513,
0.015015374,
-0.02... | Introduction: how the agent should behave, explanation of the concept of tools.
Description of all the tools. This is defined by a <<all_tools>> token that is dynamically replaced at runtime with the tools defined/chosen by the user.
A set of examples of tasks and their solution
Current example, and request for solu... |
[
0.052167982,
-0.026235908,
-0.026205525,
-0.0129204625,
0.04192884,
-0.020068115,
-0.01289008,
0.019141426,
-0.0007648025,
0.043994896,
-0.030261684,
0.010808829,
0.021663234,
-0.020478288,
-0.013604085,
-0.018002056,
-0.006080441,
-0.012411544,
-0.025673818,
-0.020235222,
-0... |
To better understand each part, let's look at a shortened version of how the run prompt can look like:
````text
I will ask you to perform a task, your job is to come up with a series of simple commands in Python that will perform the task.
[]
You can print intermediate results if it makes sense to do so.
Tools:
- doc... |
[
0.024357911,
-0.021135129,
-0.010459659,
-0.009150403,
-0.0040536574,
0.006010347,
-0.005438447,
-0.0217394,
0.00012274273,
0.029249636,
0.04293208,
-0.012776034,
0.031163163,
-0.027825281,
-0.0025861398,
0.0385583,
-0.0001472463,
-0.01939425,
-0.022127861,
0.0029044617,
-0.0... | from transformers import load_tool
document_qa = load_tool("document-question-answering")
print(f"- {document_qa.name}: {document_qa.description}") |
[
0.04848687,
-0.023013694,
0.009523161,
0.012077798,
-0.025414614,
0.018416813,
-0.016996756,
0.006459792,
0.009252326,
0.060140114,
0.0000786315,
0.013585693,
0.0016012233,
0.013710131,
-0.0075175143,
0.012692668,
-0.0020221162,
-0.005186133,
-0.03103628,
-0.005914461,
-0.017... |
which gives:
text
- document_qa: This is a tool that answers a question about a document (pdf). It takes an input named `document` which should be the document containing the information, as well as a `question` that is the question about the document. It returns a text that contains the answer to the question.
We ca... |
[
0.0109626455,
-0.028417379,
-0.034634132,
-0.028692713,
-0.006361667,
-0.015404219,
-0.018085103,
0.03130114,
0.028040607,
0.037503406,
0.032112654,
0.0043872315,
0.045879357,
0.0014310129,
0.017722823,
0.0142521635,
0.023968559,
0.00071007217,
-0.04738645,
0.012868247,
-0.00... | Check the naming and description of the curated Transformers tools to better understand what name and
description a tool is expected to have. You can see all tools with the [Agent.toolbox] property. |
[
0.054876972,
-0.020029785,
0.003770085,
-0.009427146,
-0.006867355,
-0.059084002,
-0.010734109,
0.009728753,
0.0022581844,
0.067993,
-0.015714489,
-0.0061056046,
0.039193418,
0.014353391,
-0.010966115,
-0.0035245463,
-0.0027531288,
-0.011004782,
-0.055712193,
-0.022643711,
-0... |
The third part includes a set of curated examples that show the agent exactly what code it should produce
for what kind of user request. The large language models empowering the agent are extremely good at
recognizing patterns in a prompt and repeating the pattern with new data. Therefore, it is very important
that ... |
[
0.04527466,
-0.024008842,
-0.013567651,
-0.0072889253,
-0.0066547855,
-0.0652427,
-0.025306618,
0.053002324,
0.006533119,
0.050524753,
-0.013951085,
-0.04521567,
0.02807914,
0.022312887,
0.007572814,
-0.010153617,
0.028683783,
0.0005502641,
-0.03495145,
0.0015927242,
0.025188... |
which is probably not what we wanted. Instead, it is more likely that we want an image of a tree to be generated.
To steer the agent more towards using a specific tool it can therefore be very helpful to use important keywords that
are present in the tool's name and description. Let's have a look.
py
agent.toolbox["... |
[
0.04642897,
0.0016253062,
-0.015807472,
-0.017414516,
0.016318804,
-0.06539209,
0.016903184,
0.031498067,
0.008948315,
0.03544263,
-0.004978185,
-0.011899432,
0.03555951,
-0.043799262,
0.012228146,
0.013185068,
0.020102663,
-0.042572062,
-0.017253812,
-0.034682937,
0.02584419... | from transformers import HfAgent
agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoder")
agent.run("Show me a tree", return_code=True)
gives:
``text
==Explanation from the agent==
I will use the following tool:image_segmenter` to create a segmentation mask for the image.
==Code generated by th... |
[
0.01975109,
-0.02609058,
-0.010608175,
0.007569258,
-0.0029267797,
-0.06752152,
-0.015998235,
0.019317495,
-0.025507465,
0.058490742,
-0.018136317,
0.012036054,
0.01734388,
-0.000027581653,
-0.0193773,
-0.008514948,
-0.041475795,
-0.025746692,
-0.06345468,
-0.0272269,
0.01005... |
is a final and unfinished example that the agent is tasked to complete. The unfinished example
is dynamically created based on the actual user input. For the above example, the user ran:
py
agent.run("Draw me a picture of rivers and lakes")
The user input - a.k.a the task: "Draw me a picture of rivers and lakes" is c... |
[
0.038995232,
-0.028261552,
-0.020296933,
-0.03151591,
-0.022252403,
-0.051927034,
-0.021381719,
0.03862412,
-0.004467609,
0.043048907,
-0.0021642211,
-0.017270949,
0.046531644,
0.019611804,
0.008371414,
-0.011383125,
0.02654873,
-0.0032168925,
-0.056037802,
-0.0052954727,
0.0... |
Much better! That looks more like what we want. In short, when you notice that the agent struggles to
correctly map your task to the correct tools, try looking up the most pertinent keywords of the tool's name
and description and try refining your task request with it.
Customizing the tool descriptions
As we've seen... |
[
0.037045218,
-0.0224389,
-0.027646119,
-0.012822229,
-0.024208484,
-0.07844187,
-0.005334134,
0.042266943,
-0.015723186,
0.050766744,
-0.025310848,
-0.024948228,
0.03231666,
0.004177378,
0.0129745295,
-0.029473722,
0.034028225,
-0.020538775,
-0.03446337,
-0.009326576,
0.01760... |
which is probably not exactly what we want here. It seems like the agent has a difficult time
to understand the difference between image_generator and image_transformer and often uses the two together.
We can help the agent here by changing the tool name and description of image_transformer. Let's instead call it mo... |
[
0.030732336,
-0.024633106,
-0.02681438,
-0.0024591426,
-0.030176597,
-0.07296846,
-0.0056824256,
0.023007572,
0.041680384,
0.04045776,
-0.013212682,
-0.014213011,
0.027161716,
-0.0037547078,
0.0019068775,
-0.0043382333,
0.019881543,
0.009065484,
-0.013157108,
0.0028689997,
0.... | Agents are still brittle for many use cases, especially when it comes to
slightly more complex use cases like generating an image of multiple objects.
Both the agent itself and the underlying prompt will be further improved in the coming
months making sure that agents become more robust to a variety of user inputs. |
[
0.03077175,
0.018411906,
-0.008019692,
-0.033385787,
-0.019633684,
-0.08455838,
0.0019694061,
0.057395138,
0.003224925,
0.034834873,
-0.008864991,
-0.016905993,
0.041000586,
0.0057430654,
-0.004475116,
-0.0014375423,
0.017758397,
-0.0066380887,
-0.034550738,
-0.0107473815,
0.... | which is definitely closer to what we had in mind! However, we want to have both the house and car in the same image. Steering the task more toward single image generation should help:
py
agent.run("Create image: 'A house and car'", return_code=True)
``text
==Explanation from the agent==
I will use the following tool:i... |
[
0.0007050473,
-0.031144852,
-0.000116210475,
-0.0030248086,
-0.013230869,
-0.02361486,
-0.020753745,
0.01710974,
0.01723785,
0.021963669,
0.01830543,
0.010853725,
0.008206128,
0.0076225176,
-0.013544025,
0.014803769,
-0.021508168,
-0.047571342,
-0.04170677,
-0.03023385,
-0.00... | Customizing the whole prompt
To give the user maximum flexibility, the whole prompt template as explained in above
can be overwritten by the user. In this case make sure that your custom prompt includes an introduction section,
a tool section, an example section, and an unfinished example section. If you want to overw... |
[
0.0024397504,
-0.02756161,
-0.015395293,
0.034653824,
-0.030617604,
-0.029954512,
-0.017730534,
0.01797559,
0.03557639,
0.02787874,
0.00015845313,
0.008879682,
0.0024397504,
-0.002782108,
-0.029334664,
-0.014523181,
-0.02218479,
-0.032924015,
-0.034653824,
-0.037911627,
0.009... | template = """ [] """
agent = HfAgent(your_endpoint, run_prompt_template=template)
Please make sure to have the <<all_tools>> string and the <<prompt>> defined somewhere in the template so that the agent can be aware
of the tools, it has available to it as well as correctly insert the user's prompt.
Similarly, one c... |
[
-0.0143436575,
-0.034620635,
-0.015812587,
0.035254292,
-0.028197672,
-0.026829552,
-0.0022627984,
0.018980864,
0.026512725,
0.010484119,
0.011895443,
0.014106037,
0.00029005043,
-0.0032348838,
-0.048129022,
0.0065957783,
-0.01983054,
-0.043607023,
-0.021789111,
-0.034735847,
... | Similarly, one can overwrite the chat prompt template. Note that the chat mode always uses the following format for the exchanges:
```text
Human: <>
Assistant:
Therefore it is important that the examples of the custom chat prompt template also make use of this format.
You can overwrite the chat template at instantiati... |
[
-0.007462165,
-0.0030078846,
0.008444752,
0.008918867,
-0.0126018515,
-0.027581152,
-0.0027828515,
0.0025234623,
0.050902136,
0.034081344,
0.027539924,
0.0034081342,
0.034493618,
0.002056218,
-0.0094891805,
-0.004555631,
-0.008135546,
0.0007189033,
-0.050847165,
0.007352225,
... | Please make sure to have the <<all_tools>> string defined somewhere in the template so that the agent can be aware
of the tools, it has available to it. |
[
0.015874846,
-0.017180441,
-0.019732285,
0.012744386,
-0.028159307,
-0.032699216,
-0.027818073,
0.0019899195,
0.008115459,
0.022298967,
-0.02710593,
-0.0060495036,
0.01534074,
-0.0099106515,
-0.0057119774,
-0.0055710324,
0.03204642,
-0.010229632,
-0.06551712,
0.0021345734,
0.... |
In both cases, you can pass a repo ID instead of the prompt template if you would like to use a template hosted by someone in the community. The default prompts live in this repo as an example.
To upload your custom prompt on a repo on the Hub and share it with the community just make sure:
- to use a dataset reposit... |
[
0.04216801,
-0.007600725,
-0.005008907,
-0.017662222,
-0.0041170595,
-0.049273666,
0.010658489,
-0.015871245,
0.00091004855,
0.029907836,
0.040828418,
-0.018492186,
0.030635873,
-0.040013015,
0.0065523493,
0.009333458,
-0.0062356526,
-0.043245506,
-0.011350125,
0.011379247,
-... | We replace huggingface-tools/image-transformation,
with diffusers/controlnet-canny-tool
to allow for more image modifications.
We add a new tool for image upscaling to the default toolbox:
diffusers/latent-upscaler-tool replace the existing image-transformation tool.
We'll start by loading the custom tools wit... |
[
0.021957207,
0.0017804117,
-0.017652439,
-0.040360812,
0.0045611765,
-0.016048985,
-0.013571576,
-0.019111438,
-0.003053424,
0.04379885,
0.02915108,
0.00021792437,
0.040360812,
-0.048276965,
0.029107744,
0.047670253,
-0.02369067,
-0.04628348,
-0.045618985,
0.020527098,
-0.016... | We'll start by loading the custom tools with the convenient [load_tool] function:
from transformers import load_tool
controlnet_transformer = load_tool("diffusers/controlnet-canny-tool")
upscaler = load_tool("diffusers/latent-upscaler-tool") |
[
0.046655856,
-0.029122286,
-0.012770159,
-0.015742589,
0.0051998706,
-0.047227766,
-0.014365489,
0.020739282,
0.002227441,
0.033170808,
0.019670712,
-0.029167436,
0.019610511,
-0.01498255,
0.02396004,
0.010550244,
0.00979773,
-0.036391567,
-0.040455144,
-0.026322933,
0.001500... |
Upon adding custom tools to an agent, the tools' descriptions and names are automatically
included in the agents' prompts. Thus, it is imperative that custom tools have
a well-written description and name in order for the agent to understand how to use them.
Let's take a look at the description and name of controlnet... |
[
0.044889268,
-0.038641486,
-0.013494911,
-0.004426745,
0.013406079,
-0.033696562,
-0.016641008,
0.010837383,
-0.014249974,
0.026101511,
0.0036624284,
-0.035946947,
0.030409815,
-0.0011196408,
0.023703074,
-0.009586346,
0.016655814,
-0.01595997,
-0.0077431025,
0.00096973847,
-... |
The upscaler tool was given the name image_upscaler which is not yet present in the default toolbox and is therefore simply added to the list of tools.
You can always have a look at the toolbox that is currently available to the agent via the agent.toolbox attribute:
py
print("\n".join([f"- {a}" for a in agent.toolbo... |
[
0.008008206,
0.0066554197,
0.015336402,
-0.036778428,
0.0065143537,
-0.051536098,
0.028762987,
-0.0014902352,
0.02678083,
0.04143722,
-0.011524004,
-0.03437669,
0.048642438,
-0.031483028,
0.014511708,
0.008963114,
0.00592477,
-0.038948674,
-0.038948674,
-0.017752608,
0.004796... | from diffusers.utils import load_image
image = load_image(
"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/rivers_and_lakes.png"
) |
[
0.027867295,
-0.0030923046,
0.0017161195,
-0.036785997,
0.007917177,
-0.05927283,
0.020074394,
0.039183814,
-0.014533101,
0.05860027,
0.0040682447,
-0.003487067,
0.054594163,
-0.006656131,
0.024358295,
-0.027881915,
-0.0049418393,
-0.031405535,
-0.025571825,
0.014569653,
-0.0... | Let's transform the image into a beautiful winter landscape:
py
image = agent.run("Transform the image: 'A frozen lake and snowy forest'", image=image)
``text
==Explanation from the agent==
I will use the following tool:image_transformer` to transform the image.
==Code generated by the agent==
image = image_transformer... |
[
0.016622927,
0.0028161234,
-0.022196252,
0.013247045,
-0.039262827,
-0.038597357,
-0.031304896,
0.01732999,
0.032053553,
0.07519829,
0.029142112,
-0.017829094,
0.0041176057,
-0.003569978,
0.0021749139,
0.015527671,
0.005597587,
0.001904566,
-0.031693086,
0.002065735,
-0.02733... | Overwriting existing tools can be beneficial if we want to use a custom tool exactly for the same task as an existing tool
because the agent is well-versed in using the specific task. Beware that the custom tool should follow the exact same API
as the overwritten tool in this case, or you should adapt the prompt temp... |
[
0.073275104,
-0.048288677,
0.0052699265,
0.018346384,
0.005825564,
-0.038791075,
-0.016041007,
0.0040102517,
-0.022625826,
0.05505296,
0.01293496,
-0.01931271,
0.011002309,
0.025759483,
0.011340523,
-0.016883092,
0.018194534,
-0.0501385,
0.009283629,
0.020334255,
-0.026422108... | The new image processing tool is based on ControlNet which can make very strong modifications to the image.
By default the image processing tool returns an image of size 512x512 pixels. Let's see if we can upscale it.
py
image = agent.run("Upscale the image", image)
``text
==Explanation from the agent==
I will use the ... |
[
0.022819497,
-0.023746097,
-0.031818513,
0.0057127266,
-0.026667245,
-0.0026718285,
0.012611188,
0.006611843,
0.021908602,
0.025316607,
-0.010467443,
-0.011574652,
0.020416617,
-0.021720141,
0.016647397,
0.017322715,
0.003252917,
-0.051135775,
-0.053146027,
-0.016396115,
0.02... |
This class has a few needs:
- An attribute name, which corresponds to the name of the tool itself. To be in tune with other tools which have a
performative name, we'll name it model_download_counter.
- An attribute description, which will be used to populate the prompt of the agent.
- inputs and outputs attributes.... |
[
0.034873053,
-0.016577799,
-0.023549499,
0.013834239,
-0.014802126,
0.008725541,
0.022326905,
-0.012073121,
0.038744602,
0.03164191,
0.013630473,
-0.002110431,
0.010159178,
-0.015282432,
0.017087214,
0.017960496,
-0.009904471,
-0.020929653,
0.003353038,
-0.025427055,
0.008274... | For the task text-classification, this returns 'facebook/bart-large-mnli', for translation it returns 'google-t5/t5-base.
How do we convert this to a tool that the agent can leverage? All tools depend on the superclass Tool that holds the
main attributes necessary. We'll create a class that inherits from it:
thon
from ... |
[
0.034691185,
0.0043837307,
-0.04077889,
-0.011986081,
-0.037021406,
0.012175411,
-0.0065755956,
-0.005872888,
0.019646686,
0.019457355,
0.0035899985,
0.011767622,
0.029317109,
-0.01711257,
0.0031785688,
0.0035226406,
0.026826683,
-0.01801553,
-0.047099616,
0.0022373775,
0.021... |
In order to let others benefit from it and for simpler initialization, we recommend pushing it to the Hub under your
namespace. To do so, just call push_to_hub on the tool variable:
python
tool.push_to_hub("hf-model-downloads")
You now have your code on the Hub! Let's take a look at the final step, which is to have ... |
[
0.000052188763,
-0.01698297,
-0.03866089,
-0.0021482299,
-0.015345533,
-0.004108082,
-0.007839409,
0.010114431,
0.03367613,
0.051586498,
-0.0029977406,
-0.0023583435,
0.015374515,
-0.015968628,
-0.0063722366,
0.018605916,
0.032690767,
-0.040399764,
-0.045906186,
0.0016446818,
... | def __call__(self, task: str):
model = next(iter(list_models(filter=task, sort="downloads", direction=-1)))
return model.id
We now have our tool handy. Save it in a file and import it from your main script. Let's name this file
model_downloads.py, so the resulting import code looks like this:
thon
from model_d... |
[
0.052864928,
-0.013803955,
-0.03255081,
-0.0072372807,
0.012598369,
-0.028632658,
-0.006193696,
0.022815706,
0.002369729,
0.0533773,
-0.012613439,
-0.024729574,
0.030983549,
-0.010511199,
0.027924376,
-0.011106458,
0.012816882,
-0.038940415,
-0.010202268,
-0.008107563,
-0.015... |
The agent automatically mapped our prompt "Upscale the image" to the just added upscaler tool purely based on the description and name of the upscaler tool
and was able to correctly run it.
Next, let's have a look at how you can create a new custom tool.
Adding new tools
In this section, we show how to create a ne... |
[
0.040276475,
0.0068309987,
-0.026931494,
0.031460334,
-0.018356893,
-0.01723978,
0.010703156,
0.021829003,
0.018281413,
0.021511985,
-0.018296508,
-0.028848704,
0.038585708,
-0.032577448,
0.036774173,
-0.014620601,
0.01665103,
-0.037196863,
-0.03689494,
-0.025769094,
0.011571... |
In order to use it in the agent, simply pass it in the additional_tools parameter of the agent initialization method:
thon
from transformers import HfAgent
agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoder", additional_tools=[tool])
agent.run(
"Can you read out loud the name of the mo... |
[
0.019150043,
-0.024484484,
0.0034164398,
0.006042453,
-0.034524024,
-0.03017855,
0.007919247,
0.019075122,
0.028964816,
0.028620174,
0.04141684,
0.014459931,
-0.0035194573,
-0.0032253887,
-0.013418516,
0.046601437,
0.0083762705,
0.021952122,
-0.020139012,
-0.017112168,
0.0425... | Depending on the LLM, some are quite brittle and require very exact prompts in order to work well. Having a well-defined
name and description of the tool is paramount to having it be leveraged by the agent. |
[
-0.018276816,
0.017580045,
-0.02030013,
0.020929903,
0.008877119,
-0.07750227,
-0.04100224,
0.027334828,
0.01818302,
0.038777936,
0.013881804,
0.017807836,
0.045960028,
-0.024695141,
-0.009366198,
-0.0037384396,
-0.03124746,
-0.049845863,
-0.042636972,
-0.019603359,
-0.009413... | and generates the following audio.
| Audio |
|---------------------------------------------------------------------------------------------------------------------------------------... |
[
0.02941859,
-0.001303536,
-0.027011475,
-0.0075488924,
-0.019851072,
-0.008059261,
-0.021481207,
0.033882413,
-0.005187483,
0.045674227,
0.012523087,
-0.007815503,
0.0020433809,
-0.030347917,
0.022776173,
0.022821877,
0.00013961356,
-0.04067718,
-0.041499864,
-0.016164226,
-0... | We pass that instance to the Tool.from_gradio method:
thon
from transformers import Tool
tool = Tool.from_gradio(gradio_tool)
Now we can manage it exactly as we would a usual custom tool. We leverage it to improve our prompt
a rabbit wearing a space suit:
thon
from transformers import HfAgent
agent = HfAgent("https://... |
[
0.045112923,
0.010735584,
-0.027205614,
-0.016264705,
-0.027366942,
-0.03335071,
-0.0061670947,
-0.0044328286,
0.020561872,
0.024199065,
0.05526186,
-0.008337677,
0.03481732,
-0.04176905,
0.023128439,
0.008117686,
0.021676496,
-0.015590064,
-0.0120701995,
-0.0073513826,
-0.00... | Replacing existing tools
Replacing existing tools can be done simply by assigning a new item to the agent's toolbox. Here's how one would do so:
thon
from transformers import HfAgent, load_tool
agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoder")
agent.toolbox["image-transformation"] = load_... |
[
0.0067893704,
-0.019057155,
-0.011750302,
0.015220885,
-0.059337992,
-0.031214545,
-0.014627505,
0.04374452,
0.018505175,
0.065133795,
0.049567923,
0.017663402,
0.005205874,
-0.009859766,
-0.009100792,
-0.006289137,
0.007437948,
-0.0076656407,
-0.023169415,
-0.007879534,
0.00... | Beware when replacing tools with others! This will also adjust the agent's prompt. This can be good if you have a better
prompt suited for the task, but it can also result in your tool being selected way more than others or for other
tools to be selected instead of the one you have defined. |
[
0.026045015,
0.01699637,
-0.037159767,
0.005983416,
0.013437237,
-0.017599612,
-0.010594455,
0.02866912,
0.0038287076,
0.07739607,
0.010458725,
-0.009915806,
0.025094908,
-0.02738723,
0.04847057,
0.011906507,
0.003694863,
-0.021852477,
-0.03818528,
0.008015591,
-0.0069712265,... |
Leveraging gradio-tools
gradio-tools is a powerful library that allows using Hugging
Face Spaces as tools. It supports many existing Spaces as well as custom Spaces to be designed with it.
We offer support for gradio_tools by using the Tool.from_gradio method. For example, we want to take
advantage of the StableDiffu... |
[
-0.011802606,
-0.008376283,
-0.02463088,
-0.0008779489,
0.0056746155,
-0.034783497,
-0.025374116,
0.016291758,
0.019175518,
0.052977946,
0.008547227,
-0.017213373,
0.040342912,
-0.031542987,
0.022103874,
-0.011423555,
-0.00615772,
0.006559068,
-0.05773466,
0.003861117,
0.0037... | Before finally generating the image:
gradio-tools requires textual inputs and outputs, even when working with different modalities. This implementation
works with image and audio objects. The two are currently incompatible, but will rapidly become compatible as we
work to improve the support. |
[
0.039521936,
0.01983582,
-0.014633595,
0.029401924,
-0.023847895,
-0.023788013,
-0.0077022864,
-0.0073729367,
-0.00020596037,
0.05613911,
-0.024880854,
-0.0044873864,
0.00037472858,
-0.0028818077,
-0.023024522,
0.0068826554,
0.0056213965,
0.014708447,
-0.028129438,
-0.001434354... |
Future compatibility with Langchain
We love Langchain and think it has a very compelling suite of tools. In order to handle these tools,
Langchain requires textual inputs and outputs, even when working with different modalities.
This is often the serialized version (i.e., saved to disk) of the objects.
This differenc... |
[
0.042809863,
0.008567429,
0.04750285,
0.034051437,
-0.022960166,
-0.024365332,
0.0036425216,
-0.013983463,
-0.030231565,
0.08572886,
0.0008935774,
0.021554997,
0.019767843,
-0.030286135,
-0.06575638,
0.025402155,
-0.008785708,
-0.046138607,
-0.0351974,
0.01810347,
0.011787036... | True or 'longest': pad to the longest sequence in the batch (no padding is applied if you only provide
a single sequence).
'max_length': pad to a length specified by the max_length argument or the maximum length accepted
by the model if no max_length is provided (max_length=None). Padding will still be applied ... |
[
0.037439167,
-0.014656698,
-0.0154288635,
0.014620616,
0.016872162,
-0.04687834,
-0.029414427,
0.04910102,
0.01082474,
0.07458968,
-0.009042267,
-0.0333402,
0.029515458,
-0.015284534,
-0.008464946,
-0.0026448448,
0.02875051,
-0.036226798,
-0.023006182,
-0.001330541,
0.0141804... | The model adequately leverages the tool:
``text
==Explanation from the agent==
I will use the following tools:StableDiffusionPromptGeneratorto improve the prompt, thenimage_generator` to generate an image according to the improved prompt.
==Code generated by the agent==
improved_prompt = StableDiffusionPromptGenerator... |
[
0.009895708,
-0.008438463,
0.059970703,
0.027572425,
-0.045276254,
-0.0193983,
0.0010971697,
-0.01862562,
-0.016443143,
0.052867483,
0.07732208,
0.000022306116,
0.005998426,
-0.02944312,
-0.032913398,
0.006269541,
-0.02509172,
-0.011549512,
-0.00072311534,
0.025986401,
-0.039... | The truncation argument controls truncation. It can be a boolean or a string: |
[
0.029879646,
0.023563389,
0.05226054,
0.043233193,
-0.046376903,
-0.02334708,
-0.015011926,
-0.0023091112,
-0.062297333,
0.074295335,
0.014781196,
0.019338131,
-0.011976373,
-0.020549467,
-0.05378913,
0.03671505,
-0.038185958,
-0.056788635,
-0.014146686,
0.03700346,
0.0102747... |
The max_length argument controls the length of the padding and truncation. It can be an integer or None, in which case it will default to the maximum length the model can accept. If the model has no specific maximum input length, truncation or padding to max_length is deactivated.
The following table summarizes the r... |
[
0.02986606,
0.028872417,
0.05175459,
0.021732386,
-0.040228333,
-0.006969694,
-0.010170643,
-0.006224462,
-0.04760968,
0.07801515,
0.0034777494,
0.021916918,
-0.010781024,
-0.044401634,
-0.048262645,
0.038638506,
-0.005489876,
-0.059107546,
0.0017858953,
0.01977349,
-0.022953... |
Padding and truncation
Batched inputs are often different lengths, so they can't be converted to fixed-size tensors. Padding and truncation are strategies for dealing with this problem, to create rectangular tensors from batches of varying lengths. Padding adds a special padding token to ensure shorter sequences will ... |
[
0.026198851,
0.010533937,
-0.07980211,
0.016348554,
0.004039357,
-0.017627621,
0.032902934,
-0.027683746,
0.0123055205,
0.03399088,
-0.018362718,
-0.0025765144,
0.036313783,
-0.05322101,
0.026169447,
0.019538874,
-0.013305252,
-0.052926973,
-0.056837685,
0.015584053,
0.006957... |
Distributed training with 🤗 Accelerate
As models get bigger, parallelism has emerged as a strategy for training larger models on limited hardware and accelerating training speed by several orders of magnitude. At Hugging Face, we created the 🤗 Accelerate library to help users easily train a 🤗 Transformers model on ... |
[
0.022428095,
0.01236683,
0.033860423,
0.049139902,
-0.037762146,
-0.023778694,
-0.007844376,
0.005317123,
-0.030859096,
0.07339608,
0.018471802,
0.008233185,
0.004096129,
-0.022005182,
-0.059535407,
0.028048763,
-0.03145936,
-0.066411175,
-0.025061078,
0.014829283,
-0.0126192... |
True or 'longest_first': truncate to a maximum length specified by the max_length argument or
the maximum length accepted by the model if no max_length is provided (max_length=None). This will
truncate token by token, removing a token from the longest sequence in the pair until the proper length is
reache... |
[
-0.0013517466,
0.025886731,
-0.045844566,
-0.032233156,
-0.010925313,
0.0038308187,
-0.00077373144,
0.01569905,
0.011683823,
0.015462451,
-0.011475059,
0.005901061,
0.02624859,
-0.031620782,
0.022059392,
0.044063114,
-0.02919912,
-0.043422904,
-0.09079841,
0.025051676,
0.0085... | from accelerate import Accelerator
accelerator = Accelerator()
Prepare to accelerate
The next step is to pass all the relevant training objects to the [~accelerate.Accelerator.prepare] method. This includes your training and evaluation DataLoaders, a model and an optimizer:
train_dataloader, eval_dataloader, model, o... |
[
0.000343673,
0.008080104,
-0.043962423,
-0.010831221,
-0.0029070359,
-0.014316892,
-0.017130377,
-0.020304209,
-0.012986378,
0.027067658,
0.006811958,
-0.009105709,
0.005568065,
-0.027123095,
-0.012487435,
0.029215885,
-0.020692276,
-0.05225042,
-0.10483347,
0.024683818,
0.02... | train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
train_dataloader, eval_dataloader, model, optimizer
)
Backward
The last addition is to replace the typical loss.backward() in your training loop with 🤗 Accelerate's [~accelerate.Accelerator.backward]method:
for epoch in range(num_epochs... |
[
-0.020260634,
0.019911312,
-0.056226753,
-0.009096326,
-0.019478153,
0.00089426246,
0.011227186,
-0.0015658326,
0.027903784,
0.052509975,
-0.013176398,
0.002915086,
0.038704798,
-0.0032818734,
0.009326878,
0.036944218,
-0.026730064,
-0.05818295,
-0.060698066,
0.019184723,
0.0... | pip install accelerate
Then import and create an [~accelerate.Accelerator] object. The [~accelerate.Accelerator] will automatically detect your type of distributed setup and initialize all the necessary components for training. You don't need to explicitly place your model on a device.
from accelerate import Accelerat... |
[
0.018995432,
0.01598598,
-0.05209939,
0.015240521,
-0.020886693,
0.0008830771,
-0.022184346,
-0.026311986,
0.023813315,
0.056654982,
-0.0070577143,
-0.015709884,
0.048454918,
-0.04594244,
0.0057186466,
0.014826377,
-0.011154294,
-0.043954547,
-0.05969204,
0.006716045,
0.02749... | As you can see in the following code, you only need to add four additional lines of code to your training loop to enable distributed training!
+ from accelerate import Accelerator
from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler
accelerator = Accelerator()
model = AutoModelForSeque... |
[
-0.0013721068,
-0.017403355,
-0.0088206865,
0.019993557,
-0.024445903,
0.010752837,
-0.03043837,
-0.02517396,
0.014477127,
0.02929028,
0.010444813,
-0.024851935,
0.03713089,
-0.057460472,
-0.009569745,
0.04561555,
-0.02556599,
-0.034498684,
-0.08831888,
-0.0012399715,
0.02727... | accelerator = Accelerator()
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
optimizer = AdamW(model.parameters(), lr=3e-5)
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)
train_dataloader, eval_dataloader, model, optimizer =... |
[
0.017152676,
0.019451192,
-0.036747526,
0.004686818,
-0.019910894,
0.016305098,
-0.011111888,
0.008590704,
-0.0020866217,
0.040712465,
-0.012598741,
0.004331266,
-0.006328102,
-0.048268836,
0.0010388215,
0.059186786,
-0.016405659,
-0.032207955,
-0.07924134,
0.030800115,
0.021... | model.to(device)
train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
train_dataloader, eval_dataloader, model, optimizer
)
num_epochs = 3
num_training_steps = num_epochs * len(train_dataloader)
lr_scheduler = get_scheduler(
"linear",
optimizer=optimizer,
num_warmup_steps=... |
[
0.029465072,
0.011380308,
-0.027810538,
-0.010545849,
0.0013631912,
-0.032026,
-0.019293291,
0.01732224,
-0.021882996,
0.041348934,
-0.010617784,
0.017926503,
-0.00024907914,
-0.033579823,
0.007200815,
0.02169596,
0.0021095295,
-0.05147755,
-0.08275542,
0.02222829,
-0.0121788... | outputs = model(**batch)
loss = outputs.loss
+ accelerator.backward(loss)
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()
progress_bar.update(1)
Train
Once you've added the relevant lines of code, launch your training in a script or a notebook like Colaboratory.
Tr... |
[
0.027924161,
0.017417626,
-0.054141536,
0.0010886017,
0.011611751,
-0.028413814,
-0.00032373876,
-0.01243017,
-0.003868252,
0.075658254,
-0.023909014,
-0.004934994,
0.007876405,
-0.011730666,
0.007946354,
0.02244006,
0.0031372712,
-0.054309417,
-0.07554633,
0.021404793,
0.021... | for epoch in range(num_epochs):
for batch in train_dataloader:
outputs = model(**batch)
loss = outputs.loss
accelerator.backward(loss)
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()
progress_bar.update(1)
As you can see in the following c... |
[
0.017332751,
0.005442256,
-0.042628046,
0.015541178,
-0.010557479,
0.017844629,
-0.008225592,
0.01709103,
0.0029610707,
0.033727057,
-0.07063913,
0.049168706,
0.030456727,
-0.0003516938,
-0.00086423807,
0.010941388,
-0.026745614,
-0.030968606,
-0.07308477,
0.031338297,
-0.004... | accelerate config
Then launch your training with:
accelerate launch train.py
Train with a notebook
🤗 Accelerate can also run in a notebook if you're planning on using Colaboratory's TPUs. Wrap all the code responsible for training in a function, and pass it to [~accelerate.notebook_launcher]:
from accelerate import ... |
[
0.06133457,
0.01604135,
-0.04169571,
0.0076078456,
-0.013262127,
-0.03721357,
0.011625554,
-0.024106255,
-0.01251756,
0.027379397,
0.004423166,
-0.012642883,
0.053284407,
-0.07023988,
0.0022465996,
-0.0028142394,
0.008853704,
-0.029030712,
-0.06292691,
-0.028101848,
-0.006424... |
Community
This page regroups resources around 🤗 Transformers developed by the community.
Community resources:
| Resource | Description | Author |
|:----------|:-------------|------:|
| Hugging Face Transformers Glossary Flashcards | A set of flashcards based on the Transformers Docs Glossary t... |
[
0.012092959,
-0.012079582,
-0.027637228,
0.012066205,
-0.004033216,
-0.01709602,
0.023998639,
0.028680647,
0.056023575,
0.03999773,
0.024185918,
0.014500849,
0.041067902,
-0.04235211,
-0.022834824,
0.02403877,
0.012253486,
-0.01638703,
-0.06330076,
-0.022821447,
-0.004618467,... | Troubleshoot
Sometimes errors occur, but we are here to help! This guide covers some of the most common issues we've seen and how you can resolve them. However, this guide isn't meant to be a comprehensive collection of every 🤗 Transformers issue. For more help with troubleshooting your issue, try: |
[
0.030058522,
0.0054668393,
-0.015465735,
0.044054795,
-0.021401783,
-0.033724904,
0.05019453,
-0.00048785083,
0.002318769,
0.01419996,
0.02855996,
0.013043304,
0.040155623,
-0.049176093,
-0.0018377382,
0.032095402,
-0.0056996252,
-0.024660792,
-0.0456261,
-0.008591267,
0.0123... |
For more details about troubleshooting and getting help, take a look at Chapter 8 of the Hugging Face course.
Firewalled environments
Some GPU instances on cloud and intranet setups are firewalled to external connections, resulting in a connection error. When your script attempts to download model weights or datasets... |
[
0.016579177,
0.022105569,
-0.041278765,
0.0280408,
-0.02209147,
-0.011095078,
0.0035932122,
-0.020371523,
0.035667785,
0.0075212508,
0.027420491,
0.0032883442,
0.039981756,
-0.045113407,
-0.036006138,
0.0023614047,
-0.013851225,
-0.008324833,
-0.05712485,
0.012681096,
0.00440... | Check the Migration guide if you use an older version of 🤗 Transformers since some important changes have been introduced between versions. |
[
0.030863268,
0.027194766,
-0.007071171,
0.048036113,
-0.025892183,
-0.0137303,
0.026756141,
0.014487926,
0.0029341371,
0.0577922,
0.038678773,
-0.0021781733,
0.040194023,
-0.048142444,
-0.03697744,
0.012221695,
0.026397265,
-0.04649428,
-0.02476239,
0.01912672,
-0.01154382,
... | Reduce the per_device_train_batch_size value in [TrainingArguments].
Try using gradient_accumulation_steps in [TrainingArguments] to effectively increase overall batch size.
Refer to the Performance guide for more details about memory-saving techniques. |
[
0.022010287,
-0.019537859,
-0.037399016,
-0.012973138,
0.009768929,
-0.027750865,
0.034557145,
0.0025683404,
0.017690644,
0.05030111,
0.01709385,
-0.010443874,
0.022905476,
-0.032425743,
-0.019623116,
0.023999596,
0.035580218,
-0.014891401,
-0.06956899,
-0.006213039,
0.005261... | Asking for help on the forums. There are specific categories you can post your question to, like Beginners or 🤗 Transformers. Make sure you write a good descriptive forum post with some reproducible code to maximize the likelihood that your problem is solved!
Create an Issue on the 🤗 Transformers repository if it is... |
[
0.04515444,
0.015037722,
-0.038605534,
0.019935643,
-0.009204241,
-0.027406352,
0.02388425,
-0.013544956,
0.0055651953,
0.06438842,
0.01728031,
-0.0075876517,
0.03315728,
-0.04300816,
0.010972171,
0.046750393,
0.020898718,
-0.005169647,
-0.055307996,
-0.029304983,
0.013758209... | Refer to the Performance guide for more details about memory-saving techniques.
Unable to load a saved TensorFlow model
TensorFlow's model.save method will save the entire model - architecture, weights, training configuration - in a single file. However, when you load the model file again, you may run into an error be... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.