vector listlengths 1.02k 1.02k | text stringlengths 2 11.8k |
|---|---|
[
0.044649933,
0.03137487,
-0.041582167,
0.011559898,
-0.009259074,
0.031570096,
-0.019842865,
-0.0078646345,
0.012494172,
0.045430817,
0.034275305,
-0.0038172763,
-0.017904595,
-0.052235678,
-0.036088075,
0.010862678,
-0.013881639,
-0.011002122,
-0.0000012051546,
-0.01808587,
... | Architectural Innovations: Considering that LLMs are always deployed in the same way during inference, namely autoregressive text generation with a long input context, specialized model architectures have been proposed that allow for more efficient inference. The most important advancement in model architectures hereby... |
[
0.041871045,
-0.012305297,
0.0030728832,
0.014466295,
-0.02108693,
0.0134614995,
0.049524006,
0.011403735,
-0.019380156,
0.04641327,
0.043825578,
-0.011520731,
-0.006644723,
-0.053928584,
0.018554296,
0.06425182,
0.005467874,
-0.033171996,
-0.06485745,
-0.033447284,
0.0249134... | Loading the weights of a model having X billion parameters requires roughly 4 * X GB of VRAM in float32 precision
Nowadays, models are however rarely trained in full float32 precision, but usually in bfloat16 precision or less frequently in float16 precision. Therefore the rule of thumb becomes:
Loading the weights o... |
[
0.024791192,
0.010956758,
-0.010043095,
-0.008395624,
-0.038503326,
-0.010438776,
0.0025233636,
-0.024086162,
-0.006733766,
0.03953929,
-0.0035449392,
-0.047280245,
0.031942222,
-0.046388164,
0.02535234,
0.036690388,
-0.006413624,
-0.05176942,
-0.04866153,
0.0062121865,
0.009... | !pip install transformers accelerate bitsandbytes optimum
thon
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("bigscience/bloom", device_map="auto", pad_token_id=0) |
[
0.03369988,
0.02677563,
0.007245335,
-0.008292348,
-0.033923242,
0.011984817,
0.004896534,
-0.008892636,
-0.027417798,
0.026482467,
0.0122361,
-0.0040659034,
-0.019655937,
-0.040289085,
-0.011593931,
0.0024098766,
-0.0023365857,
-0.031187048,
-0.046431568,
-0.027096715,
0.023... |
Throughout this guide, we will offer an analysis of auto-regressive generation from a tensor's perspective. We delve into the pros and cons of adopting lower precision, provide a comprehensive exploration of the latest attention algorithms, and discuss improved LLM architectures. While doing so, we run practical exam... |
[
0.051777467,
-0.016514257,
0.005906482,
0.009219875,
-0.038931485,
0.03156683,
0.03640164,
0.025523312,
-0.021939367,
0.05616253,
0.04944439,
-0.010695617,
-0.024890851,
-0.059648093,
0.019395469,
0.05062498,
-0.0019711698,
-0.045087438,
-0.014715257,
-0.034827515,
0.01296544... | For shorter text inputs (less than 1024 tokens), the memory requirement for inference is very much dominated by the memory requirement to load the weights. Therefore, for now, let's assume that the memory requirement for inference is equal to the memory requirement to load the model into the GPU VRAM.
To give some exam... |
[
0.040512074,
0.013231166,
-0.03342767,
0.0018380753,
-0.040660907,
0.026373032,
0.0017041266,
0.0063104774,
0.00081904116,
0.03961908,
0.027727405,
-0.013506506,
-0.021818774,
-0.031165423,
-0.0025543293,
0.019095147,
-0.0036705695,
-0.02213132,
-0.034409963,
-0.033040706,
0.... |
By using device_map="auto" the attention layers would be equally distributed over all available GPUs.
In this guide, we will use bigcode/octocoder as it can be run on a single 40 GB A100 GPU device chip. Note that all memory and speed optimizations that we will apply going forward, are equally applicable to models th... |
[
0.07372732,
0.008928559,
0.038669895,
0.002733302,
-0.020648574,
-0.032676473,
0.032840677,
0.020607524,
0.022044305,
0.028051412,
-0.009263808,
0.007512305,
0.00923644,
-0.058949016,
0.023754755,
0.042911816,
-0.022057988,
-0.024616824,
-0.010187452,
-0.024835762,
0.00350642... | GPT3 requires 2 * 175 GB = 350 GB VRAM
Bloom requires 2 * 176 GB = 352 GB VRAM
Llama-2-70b requires 2 * 70 GB = 140 GB VRAM
Falcon-40b requires 2 * 40 GB = 80 GB VRAM
MPT-30b requires 2 * 30 GB = 60 GB VRAM
bigcode/starcoder requires 2 * 15.5 = 31 GB VRAM |
[
0.030377554,
0.010893769,
-0.008175777,
0.009374891,
0.004985407,
-0.01630795,
0.030958943,
-0.03209265,
0.02675841,
0.02617702,
0.020726504,
-0.004890932,
0.040144883,
-0.060522553,
0.014847212,
0.044912267,
0.0061808876,
-0.04747038,
-0.041511144,
-0.019549191,
0.031365916,... |
As of writing this document, the largest GPU chip on the market is the A100 & H100 offering 80GB of VRAM. Most of the models listed before require more than 80GB just to be loaded and therefore necessarily require tensor parallelism and/or pipeline parallelism.
🤗 Transformers does not support tensor parallelism out ... |
[
0.01972157,
-0.040001296,
0.0067576943,
0.046034716,
-0.046592873,
-0.038884982,
0.03814077,
0.016518809,
0.04688524,
0.07383628,
0.020877752,
-0.0076480885,
0.033356562,
-0.033781826,
0.0073158517,
0.02093091,
-0.003877202,
-0.040984716,
-0.00822618,
0.009967101,
0.022631964... | Output:
Here is a Python function that transforms bytes to Giga bytes:\n\npython\ndef bytes_to_giga_bytes(bytes):\n return bytes / 1024 / 1024 / 1024\n\n\nThis function takes a single
Nice, we can now directly use the result to convert bytes into Gigabytes.
python
def bytes_to_giga_bytes(bytes):
return bytes / 102... |
[
0.027837945,
-0.007910315,
0.02253066,
0.05657249,
-0.03152557,
-0.001769698,
0.008069389,
-0.021373758,
-0.009833664,
0.06472865,
0.048445255,
-0.003580972,
-0.039826337,
-0.02413586,
-0.01376713,
0.051511046,
0.01149671,
-0.03155449,
-0.04532162,
-0.00079401414,
0.040694013... | 29.0260648727417
Close enough to our back-of-the-envelope computation! We can see the number is not exactly correct as going from bytes to kilobytes requires a multiplication of 1024 instead of 1000. Therefore the back-of-the-envelope formula can also be understood as an "at most X GB" computation.
Note that if we had ... |
[
0.017205575,
-0.041193865,
0.009755064,
0.03726565,
-0.057509046,
-0.047662325,
0.018659014,
0.029199721,
0.012943463,
0.0787214,
-0.008543865,
-0.009021797,
-0.009964569,
-0.01097281,
-0.03535392,
-0.0012406608,
0.00085765996,
-0.046798117,
-0.0004983921,
-0.014612954,
0.009... | thon
prompt = "Question: Please write a function in Python that transforms bytes to Giga bytes.\n\nAnswer:"
result = pipe(prompt, max_new_tokens=60)[0]["generated_text"][len(prompt):]
result |
[
0.01391347,
-0.028377822,
0.009059761,
0.023226338,
-0.05881028,
0.010675183,
0.012811707,
0.002021138,
0.0172262,
0.038680788,
0.01746442,
-0.0038263903,
0.002765572,
-0.063187554,
0.0014209383,
0.044576705,
-0.017717527,
-0.01667532,
-0.071465656,
-0.02434299,
0.024968313,
... |
If you are unsure in which format the model weights are stored on the Hub, you can always look into the checkpoint's config under "torch_dtype", e.g. here. It is recommended to set the model to the same precision type as written in the config when loading with from_pretrained(, torch_dtype=) except when the original ... |
[
0.005117188,
0.0058502685,
-0.012297063,
0.020957474,
-0.03495787,
-0.028532637,
0.019218205,
-0.01374885,
0.04154122,
0.052925527,
-0.0068420833,
-0.011873026,
0.026132159,
-0.01819764,
-0.0086172875,
0.018873226,
-0.0050992207,
-0.08130005,
-0.05726651,
0.0052249944,
0.0247... | Let's call it now for the next experiment.
python
flush()
In the recent version of the accelerate library, you can also use an utility method called release_memory()
thon
from accelerate.utils import release_memory
release_memory(model) |
[
0.06551464,
0.0004275958,
0.014737863,
0.023117643,
-0.01668631,
-0.037035108,
0.026179485,
0.032874517,
-0.0404046,
0.046059486,
0.015382461,
-0.02009975,
-0.018517554,
-0.046264585,
-0.006006485,
0.024699839,
0.015162712,
-0.042689994,
0.006215247,
0.0076179807,
0.01398339,... |
Now what if your GPU does not have 32 GB of VRAM? It has been found that model weights can be quantized to 8-bit or 4-bits without a significant loss in performance (see Dettmers et al.).
Model can be quantized to even 3 or 2 bits with an acceptable loss in performance as shown in the recent GPTQ paper 🤯.
Without go... |
[
0.03030856,
-0.008399681,
-0.0022149368,
-0.0038338795,
-0.038032085,
-0.0025303604,
0.044222057,
0.032176703,
-0.00060557865,
0.064743765,
0.029360546,
0.00033241478,
-0.003921013,
-0.058163434,
0.015251869,
0.047846816,
0.011006719,
-0.032371882,
-0.07210482,
-0.011864114,
... | Almost all models are trained in bfloat16 nowadays, there is no reason to run the model in full float32 precision if your GPU supports bfloat16. Float32 won't give better inference results than the precision that was used to train the model. |
[
0.02468777,
0.01112507,
0.026123263,
0.027599383,
-0.009344246,
0.025391974,
0.0029488546,
0.021410512,
0.0056167045,
0.026637873,
-0.00023106697,
-0.0057521285,
-0.0010546133,
-0.050540186,
-0.0049734414,
0.022629328,
-0.015357066,
-0.050865203,
-0.079141706,
0.014341387,
0.... | Quantize all weights to the target precision
Load the quantized weights, and pass the input sequence of vectors in bfloat16 precision
Dynamically dequantize weights to bfloat16 to perform the computation with their input vectors in bfloat16 precision |
[
0.044487853,
-0.032004166,
0.0057523586,
0.0036416885,
-0.03983591,
-0.010761291,
0.03115033,
-0.013845408,
-0.0146182785,
0.05267291,
-0.0030859583,
-0.045842215,
-0.017812807,
-0.015854869,
0.010246044,
0.020109333,
0.0077213366,
-0.035949484,
-0.02792636,
-0.010349093,
-0.... | !pip install bitsandbytes
We can then load models in 8-bit quantization by simply adding a load_in_8bit=True flag to from_pretrained.
python
model = AutoModelForCausalLM.from_pretrained("bigcode/octocoder", load_in_8bit=True, pad_token_id=0)
Now, let's run our example again and measure the memory usage.
thon
pipe = pip... |
[
0.031232882,
-0.039483078,
-0.0037006617,
0.046414364,
-0.04515158,
-0.024876865,
0.020541303,
0.010144373,
0.030531336,
0.06274638,
0.022954626,
-0.025311824,
0.0074574472,
-0.032130864,
-0.0028780976,
0.020695643,
0.019194333,
-0.058817722,
-0.022084707,
0.00068663934,
0.02... |
Output:
Here is a Python function that transforms bytes to Giga bytes:\n\npython\ndef bytes_to_giga_bytes(bytes):\n return bytes / 1024 / 1024 / 1024\n\n\nThis function takes a single
Nice, we're getting the same result as before, so no loss in accuracy! Let's look at how much memory was used this time.
python
byt... |
[
0.025930485,
-0.005802964,
-0.007990288,
-0.023418857,
-0.0071622785,
0.009618705,
-0.017843597,
-0.005530411,
0.015759774,
0.03378277,
0.061769478,
-0.01276514,
-0.03298236,
-0.01549757,
-0.0071139783,
0.022328645,
-0.004022744,
-0.035880394,
-0.011136722,
-0.0048852535,
0.0... | As a conclusion, it is important to remember that model quantization trades improved memory efficiency against accuracy and in some cases inference time. |
[
0.018856985,
0.021611696,
-0.01933977,
-0.0030759748,
0.007234664,
0.027561301,
-0.020177541,
0.0010489908,
-0.01901318,
0.07298562,
0.0398723,
-0.024267009,
0.012005708,
-0.08315249,
-0.008562321,
0.03592483,
-0.0076819495,
-0.022165477,
-0.010457959,
-0.0024192461,
0.036861... |
In a nutshell, this means that inputs-weight matrix multiplications, with \( X \) being the inputs, \( W \) being a weight matrix and \( Y \) being the output:
$$ Y = X * W $$
are changed to
$$ Y = X * \text{dequantize}(W) $$
for every matrix multiplication. Dequantization and re-quantization is performed sequentiall... |
[
0.0007999062,
0.011469768,
0.008888038,
0.0040275,
-0.023476537,
-0.034423076,
0.022099614,
-0.005387211,
-0.046897996,
0.05827138,
0.021342305,
0.013569576,
0.013555806,
-0.06289784,
-0.011607461,
0.007814038,
0.009142769,
-0.026505766,
-0.026230382,
-0.00007390204,
0.035910... | Looking at the formula, one would intuitively say that Flash Attention must be much slower compared to the default self-attention formula as more computation needs to be done. Indeed Flash Attention requires more FLOPs compared to normal attention as the softmax normalization statistics have to constantly be recomputed... |
[
0.047792196,
-0.029931339,
-0.01680937,
0.04810908,
-0.040907122,
-0.009528191,
0.017630395,
0.019330056,
0.030421073,
0.0662004,
0.025840627,
-0.031198883,
-0.023262326,
-0.029585645,
-0.0028591775,
0.01945969,
0.020093463,
-0.050615363,
-0.015613846,
-0.0048685237,
0.013626... |
Output:
Here is a Python function that transforms bytes to Giga bytes:\n\n\ndef bytes_to_gigabytes(bytes):\n return bytes / 1024 / 1024 / 1024\n\n\nThis function takes a single argument
We're almost seeing the same output text as before - just the python is missing just before the code snippet. Let's see how much ... |
[
-0.019389343,
0.03297715,
-0.018140208,
-0.0048473356,
-0.026231822,
0.0062387325,
-0.014836941,
-0.02666208,
-0.015322715,
0.05315761,
0.027522594,
-0.024316482,
0.013789056,
-0.05446226,
-0.0011649913,
-0.00069699966,
-0.0061762757,
-0.03028457,
-0.008070796,
0.0071131266,
... | However, Flash Attention is much faster in inference compared to default attention which comes from its ability to significantly reduce the demands on the slower, high-bandwidth memory of the GPU (VRAM), focusing instead on the faster on-chip memory (SRAM). |
[
0.0544215,
0.008495932,
0.013382579,
0.0026029933,
-0.00926829,
-0.003973185,
0.030017972,
-0.0017879334,
-0.02667604,
0.042063776,
0.008005783,
-0.0034551858,
-0.0037949488,
-0.030626945,
-0.0009027857,
0.0032323904,
0.0051020156,
-0.041677598,
-0.044410557,
0.0019977323,
0.... |
If GPU memory is not a constraint for your use case, there is often no need to look into quantization. However many GPUs simply can't run LLMs without quantization methods and in this case, 4-bit and 8-bit quantization schemes are extremely useful tools.
For more in-detail usage information, we strongly recommend tak... |
[
0.02170536,
0.017376699,
-0.016088963,
-0.016306171,
-0.02749242,
-0.033605296,
0.007935876,
0.0071368585,
-0.007633336,
0.07205124,
-0.0118301185,
-0.00081307825,
-0.02853192,
-0.04303836,
0.02752345,
-0.025413422,
0.034101773,
-0.026483951,
-0.05219216,
-0.029819658,
0.0412... |
Essentially, Flash Attention makes sure that all intermediate write and read operations can be done using the fast on-chip SRAM memory instead of having to access the slower VRAM memory to compute the output vector \( \mathbf{O} \) .
In practice, there is currently absolutely no reason to not use Flash Attention if a... |
[
0.003850759,
0.043988597,
-0.00093282526,
-0.02228943,
0.014447373,
-0.036933556,
-0.0030813098,
-0.012226863,
-0.03898542,
0.03946325,
0.02432724,
-0.003745355,
-0.00046114245,
-0.033082798,
-0.0153468205,
-0.0030918503,
-0.027475307,
-0.028599616,
-0.01985811,
-0.018284079,
... | By keeping track of softmax normalization statistics and by using some smart mathematics, Flash Attention gives numerical identical outputs compared to the default self-attention layer at a memory cost that only increases linearly with \( N \) . |
[
0.030549832,
0.018501436,
-0.00915542,
0.009625103,
-0.05663427,
-0.02323911,
-0.028180994,
0.011850993,
0.025934683,
0.11163486,
0.0042203423,
-0.0006636828,
0.004516447,
-0.07139185,
-0.016064528,
-0.014893724,
-0.06872351,
-0.06496604,
-0.027159944,
-0.032809757,
0.0401885... |
Question: Write a function that takes two lists and returns a list that has alternating elements from each input list.
Answer: Sure. Here is a function that does that.
def alternating(list1, list2):
results = []
for i in range(len(list1)):
results.append(list1[i])
results.append(list2[i])
retur... |
[
0.03984675,
-0.023382198,
-0.010467857,
0.022116775,
-0.059053056,
-0.033350915,
0.019712472,
0.020527966,
0.0107490625,
0.084024064,
0.011297412,
-0.01005308,
-0.016141169,
-0.02689726,
-0.0013032096,
0.016872302,
0.008225247,
-0.051348038,
-0.025083488,
-0.030426385,
0.0310... |
"""
``
For demonstration purposes, we duplicate the system prompt by ten so that the input length is long enough to observe Flash Attention's memory savings.
We append the original text prompt"Question: Please write a function in Python that transforms bytes to Giga bytes.\n\nAnswer: Here"`
python
long_prompt = 10 * ... |
[
0.02353956,
-0.0044145514,
-0.0050507556,
0.013423911,
-0.03178194,
-0.03644744,
0.012695811,
0.009437031,
0.0074789356,
0.079398304,
-0.013459256,
-0.019637506,
0.019425439,
-0.054572195,
-0.0018591305,
0.008942205,
-0.0066801454,
-0.040264666,
-0.008101002,
-0.006026269,
0.... | Let's now run the model just like before without Flash Attention and measure the peak GPU memory requirement and inference time.
thon
import time
start_time = time.time()
result = pipe(long_prompt, max_new_tokens=60)[0]["generated_text"][len(long_prompt):]
print(f"Generated in {time.time() - start_time} seconds.")
resu... |
[
0.044909246,
0.014390354,
-0.0036721886,
0.006057526,
-0.033778913,
-0.03804604,
0.0054122354,
-0.00975023,
-0.012450753,
0.044133406,
0.007598018,
-0.00997403,
0.054219335,
-0.051712774,
0.0035211234,
0.018739538,
0.00988451,
-0.023185704,
-0.028497228,
0.0012877838,
0.02379... |
37.668193340301514
As we can see the peak GPU memory requirement is now significantly higher than in the beginning, which is largely due to the longer input sequence. Also the generation takes a little over a minute now.
We call flush() to free GPU memory for our next experiment.
python
flush()
For comparison, let's ... |
[
0.026996551,
-0.025833147,
0.007513059,
0.045639027,
-0.03523849,
-0.03397697,
0.028818747,
0.015278421,
0.018235987,
0.07339249,
0.02654801,
-0.022455074,
0.032715447,
-0.04566706,
0.011865307,
0.029071052,
0.0062515377,
-0.050124437,
-0.026127502,
0.0015620083,
0.029631728,... |
Generated in 10.96854019165039 seconds.
Sure. Here is a function that does that.\n\ndef bytes_to_giga(bytes):\n return bytes / 1024 / 1024 / 1024\n\nAnswer: Sure. Here is a function that does that.\n\ndef
`
We're getting the same output as before, however this time, the model repeats the answer multiple times until... |
[
-0.0017874327,
-0.0000018100602,
-0.00062051235,
0.032513063,
0.019027855,
-0.009235367,
-0.012985226,
-0.026456147,
0.016685087,
0.07462576,
-0.012106688,
-0.0015695838,
0.046398256,
-0.05494079,
-0.012678094,
0.012299538,
0.010442465,
-0.013542348,
-0.014549453,
0.0012008477,... | start_time = time.time()
with torch.backends.cuda.sdp_kernel(enable_flash=True, enable_math=False, enable_mem_efficient=False):
result = pipe(long_prompt, max_new_tokens=60)[0]["generated_text"][len(long_prompt):]
print(f"Generated in {time.time() - start_time} seconds.")
result |
[
0.014833313,
-0.006762655,
0.0024559847,
0.023084866,
-0.049258843,
-0.045919262,
0.021554224,
0.0077436576,
0.020886308,
0.06768221,
0.00041962205,
-0.018228555,
0.039601885,
-0.051039957,
0.0062130154,
0.012140774,
0.0071661877,
-0.043414574,
-0.0072635924,
0.00012860437,
0... |
Output:
Generated in 3.0211617946624756 seconds.
Sure. Here is a function that does that.\n\ndef bytes_to_giga(bytes):\n return bytes / 1024 / 1024 / 1024\n\nAnswer: Sure. Here is a function that does that.\n\ndef
We're getting the exact same result as before, but can observe a very significant speed-up thanks to ... |
[
0.014689515,
0.016750094,
0.004038985,
-0.022931825,
-0.00752174,
-0.0013510688,
0.00968345,
-0.0035617652,
-0.018873878,
0.009057692,
0.038480967,
-0.00047958994,
-0.009854112,
-0.06447206,
-0.013855171,
-0.01615594,
-0.04657158,
-0.028671103,
-0.04520629,
-0.025270518,
0.03... | Casting the weights to a lower precision format
Replacing the self-attention algorithm with a more memory- and compute efficient version |
[
0.05034787,
0.0021923138,
-0.039784577,
0.032809358,
0.019232083,
0.008568323,
-0.0052852347,
-0.033785313,
-0.00041599246,
0.03605298,
0.011524897,
0.01809825,
-0.008116226,
-0.060681526,
-0.01890198,
0.0049371915,
-0.013096474,
-0.017122295,
-0.046501454,
0.009199824,
0.047... |
Let's now look into how we can change the architecture of an LLM so that it is most effective and efficient for task that require long text inputs, e.g.:
- Retrieval augmented Questions Answering,
- Summarization,
- Chat
Note that chat not only requires the LLM to handle long text inputs, but it also necessitat... |
[
0.032936238,
0.0119775,
0.013539783,
-0.0045585446,
0.006264225,
0.006139695,
0.018807769,
-0.006547247,
-0.0061283745,
0.030445643,
0.004664206,
0.021887051,
-0.013969976,
-0.0026358801,
-0.027879575,
-0.029962618,
0.0059736553,
-0.02940412,
-0.02960035,
-0.03163811,
0.01747... | The positional embeddings
The key-value cache
Let's go over each component in more detail
3.1 Improving positional embeddings of LLMs
Self-attention puts each token in relation to each other's tokens.
As an example, the \( \text{Softmax}(\mathbf{QK}^T) \) matrix of the text input sequence "Hello", "I", "love", "you" c... |
[
0.06774951,
0.012330946,
0.018098285,
-0.012636056,
0.0018427583,
0.011698399,
0.029320413,
-0.0054064165,
0.014868575,
0.065308616,
0.038399324,
-0.009704015,
-0.016386688,
-0.015955068,
-0.012286295,
0.0054213,
0.01346953,
-0.0025022815,
-0.044263408,
-0.026090704,
0.011192... |
Sinusoidal and learned position embeddings are both absolute positional embeddings, i.e. encoding a unique embedding for each position id: \( 0, \ldots, N \) . As shown by Huang et al. and Su et al., absolute positional embeddings lead to poor LLM performance for long text inputs. For long text inputs, it is advantag... |
[
0.057370514,
0.008288453,
-0.009081262,
0.015928246,
0.0145804705,
0.029449236,
-0.0031694325,
0.008792968,
0.04070712,
0.021852687,
0.055208307,
-0.012901158,
-0.031827662,
-0.024000479,
-0.024706798,
0.023611281,
0.009383971,
-0.005542453,
-0.013751625,
-0.012843499,
0.0160... | Recently, relative positional embeddings that can tackle the above mentioned problems have become more popular, most notably:
Rotary Position Embedding (RoPE)
ALiBi |
[
0.041417066,
0.0011908546,
-0.0042851786,
-0.017869461,
0.007598696,
-0.014597694,
0.031852275,
0.022818862,
-0.02274295,
0.034858353,
0.021406915,
0.009678659,
-0.02190793,
-0.0023608336,
-0.031639725,
-0.030106321,
-0.0017867563,
-0.027115427,
-0.035951473,
-0.016442332,
0.... |
Each word token is given a probability mass at which it attends all other word tokens and, therefore is put into relation with all other word tokens. E.g. the word "love" attends to the word "Hello" with 5%, to "I" with 30%, and to itself with 65%.
A LLM based on self-attention, but without position embeddings would ... |
[
0.035277322,
0.00070022116,
-0.01642787,
0.0015209608,
-0.014148299,
0.0098881135,
-0.0037089768,
-0.004570356,
-0.017922673,
0.042781226,
0.03312481,
0.02103186,
-0.052347958,
-0.019850967,
-0.02382714,
0.0055531883,
-0.00520191,
-0.01636808,
-0.051510867,
0.000045632325,
0.... |
Both RoPE and ALiBi argue that it's best to cue the LLM about sentence order directly in the self-attention algorithm as it's there that word tokens are put into relation with each other. More specifically, sentence order should be cued by modifying the \( \mathbf{QK}^T \) computation.
Without going into too many det... |
[
0.051120292,
0.043869186,
0.015952433,
0.048975173,
-0.049609646,
0.032146566,
-0.0023471678,
-0.0011310969,
-0.0013718563,
0.049307518,
0.045077704,
-0.0034537166,
-0.03453339,
-0.031300604,
-0.000495681,
0.039186183,
-0.0076287673,
-0.014894979,
-0.047947936,
0.015408599,
0... | By doing so, the propability score between \( \mathbf{q}_i \) and \( \mathbf{q}_j \) is only affected if \( i \ne j \) and solely depends on the relative distance \( i - j \) regardless of each vector's specific positions \( i \) and \( j \) .
RoPE is used in multiple of today's most important LLMs, such as:
Falcon
L... |
[
0.08295182,
0.036836337,
0.022357136,
0.040417217,
-0.013179189,
0.008905489,
0.015498975,
-0.0023100558,
-0.012696548,
0.044309475,
0.043375336,
0.0024735306,
-0.07410861,
-0.008274943,
-0.032165628,
0.024723629,
0.0043787914,
-0.0070839114,
-0.0123228915,
0.023602659,
0.051... | RoPE is used in multiple of today's most important LLMs, such as:
Falcon
Llama
PaLM
As an alternative, ALiBi proposes a much simpler relative position encoding scheme. The relative distance that input tokens have to each other is added as a negative integer scaled by a pre-defined value m to each query-key entry of t... |
[
0.065292165,
0.021565365,
0.022497673,
0.05789483,
-0.016506445,
0.0017929744,
0.017759712,
-0.03594737,
0.059576042,
0.04401719,
0.0062319473,
-0.008612391,
-0.016781552,
-0.051750764,
-0.02297147,
-0.007855846,
0.03411332,
-0.018478049,
-0.018141806,
0.013495548,
0.04915252... | As shown in the ALiBi paper, this simple relative positional encoding allows the model to retain a high performance even at very long text input sequences.
ALiBi is used in multiple of today's most important LLMs, such as:
MPT
BLOOM |
[
0.05677862,
0.017509485,
0.0150476815,
0.021729719,
-0.031636797,
0.012331466,
0.012832806,
0.0056681344,
0.0057242545,
0.06488985,
0.07488672,
0.009196221,
-0.046123274,
-0.03636585,
-0.007321808,
0.030559288,
0.020517524,
-0.0039545996,
-0.02621933,
0.002493605,
0.053605963... |
Both RoPE and ALiBi position encodings can extrapolate to input lengths not seen during training whereas it has been shown that extrapolation works much better out-of-the-box for ALiBi as compared to RoPE.
For ALiBi, one simply increases the values of the lower triangular position matrix to match the length of the in... |
[
0.06219284,
0.023314958,
-0.0023793026,
0.011870771,
-0.009583404,
0.008774368,
-0.011804577,
-0.01401104,
-0.007774105,
0.040716596,
0.05068981,
-0.0041738926,
-0.04127557,
-0.013621232,
-0.021873403,
0.015945373,
0.0065973243,
0.00928921,
-0.033832435,
-0.0073254574,
0.0425... |
Both RoPE and ALiBi are relative positional embeddings that are not learned during training, but instead are based on the following intuitions:
- Positional cues about the text inputs should be given directly to the \( QK^T \) matrix of the self-attention layer
- The LLM should be incentivized to learn a consta... |
[
0.080133446,
0.015173706,
0.018718671,
0.058691487,
-0.039503284,
0.014876336,
0.011949587,
-0.0062643383,
0.010587945,
0.050615538,
0.024619123,
-0.008068123,
-0.030378714,
-0.027045038,
-0.020283777,
0.004480117,
0.030957803,
-0.0056695975,
-0.041318808,
-0.011706995,
0.021... |
In conclusion, LLMs that are intended to be deployed in tasks that require handling large text inputs are better trained with relative positional embeddings, such as RoPE and ALiBi. Also note that even if an LLM with RoPE and ALiBi has been trained only on a fixed length of say \( N_1 = 2048 \) it can still be used i... |
[
0.035498556,
-0.0047162576,
0.028921487,
0.031152993,
-0.035586644,
0.027468072,
0.007171648,
-0.0113043375,
-0.019364184,
0.06254088,
0.03282662,
0.033472583,
-0.0035491216,
-0.030301496,
-0.026866153,
0.009770177,
0.012207217,
-0.034353442,
-0.037172187,
-0.026484448,
0.006... |
Output:
shape of input_ids torch.Size([1, 1])
length of key-value cache 20
shape of input_ids torch.Size([1, 1])
length of key-value cache 21
shape of input_ids torch.Size([1, 1])
length of key-value cache 22
shape of input_ids torch.Size([1, 1])
length of key-value cache 23
shape of input_ids torch.Size([1, 1])
leng... |
[
0.022328125,
0.010083924,
-0.0035715539,
0.024535708,
-0.018843297,
0.024267644,
-0.009374344,
-0.02746864,
-0.036267433,
0.045223914,
0.017140305,
0.023037706,
-0.0017552256,
-0.030480413,
-0.03724508,
0.005826442,
0.0009840499,
-0.028840495,
-0.03336604,
-0.0335868,
0.00789... |
Output:
shape of input_ids torch.Size([1, 21])
shape of input_ids torch.Size([1, 22])
shape of input_ids torch.Size([1, 23])
shape of input_ids torch.Size([1, 24])
shape of input_ids torch.Size([1, 25])
[' Here is a Python function']
As we can see every time we increase the text input tokens by the just sampled token... |
[
0.019284276,
0.017187847,
0.0050867125,
0.034289543,
-0.04988353,
0.036012635,
-0.017374516,
0.0077969935,
-0.008292383,
0.047844537,
0.050773792,
-0.008622642,
0.0041282424,
-0.039659847,
-0.028287435,
0.004200038,
0.002855667,
-0.055943068,
-0.020289414,
-0.0031661824,
0.03... | Using the key-value cache has two advantages:
- Significant increase in computational efficiency as less computations are performed compared to computing the full \( \mathbf{QK}^T \) matrix. This leads to an increase in inference speed
- The maximum required memory is not increased quadratically with the number of ... |
[
0.018138789,
0.041389547,
0.011313143,
0.022016335,
-0.04316131,
0.0063827042,
0.012046537,
-0.020651206,
-0.0031550454,
0.027912531,
0.0052717216,
-0.008858816,
0.034621995,
-0.058148686,
-0.026997603,
-0.0005750061,
0.015873255,
-0.037148934,
-0.028754843,
-0.001880683,
0.0... | One should always make use of the key-value cache as it leads to identical results and a significant speed-up for longer input sequences. Transformers has the key-value cache enabled by default when making use of the text pipeline or the generate method.
Note that, despite our advice to use key-value caches, your LLM ... |
[
-0.018792279,
0.008866888,
0.029576747,
0.044948064,
-0.058171693,
0.016030965,
0.016030965,
0.002531205,
-0.017135492,
0.011543829,
0.045899183,
-0.01928318,
0.017626392,
-0.027429057,
-0.063019335,
0.0004602191,
0.0019175796,
-0.042156067,
-0.039394755,
0.017258216,
0.02026... | Making use of the key-value cache means that the \( \mathbf{QK}^T \) is essentially reduced to \( \mathbf{q}_c\mathbf{K}^T \) with \( \mathbf{q}_c \) being the query projection of the currently passed input token which is always just a single vector. |
[
0.043067247,
-0.03830679,
0.004744959,
0.03721585,
-0.050108753,
-0.05077819,
0.009917616,
0.005634445,
0.010469283,
0.06887784,
0.02915779,
-0.014554101,
-0.019872421,
-0.010859789,
-0.012173873,
0.0045930957,
0.010196549,
-0.03567862,
-0.00257858,
-0.011504434,
0.018483955,... | Output:
is a modified version of the function that returns Mega bytes instead.
def bytes_to_megabytes(bytes):
return bytes / 1024 / 1024
Answer: The function takes a number of bytes as input and returns the number of |
[
0.05412732,
0.019869134,
-0.019088453,
0.042891614,
-0.0416364,
-0.006425323,
-0.019425217,
-0.01249092,
-0.010975477,
0.030967072,
0.014052285,
-0.005847465,
0.0036776268,
-0.008357895,
-0.03496233,
-0.019654829,
-0.022578562,
-0.037319686,
-0.03104361,
-0.029727165,
0.05225... |
3.2.1 Multi-round conversation
The key-value cache is especially useful for applications such as chat where multiple passes of auto-regressive decoding are required. Let's look at an example.
User: How many people live in France?
Assistant: Roughly 75 million people live in France
User: And how many are in Germany?
A... |
[
0.033471078,
0.042778544,
-0.02687829,
0.0039265873,
-0.032695457,
-0.003425043,
0.01581076,
-0.0074131577,
0.0075474,
0.032814782,
0.032635793,
-0.004157782,
-0.0043069404,
-0.047999077,
0.00017059958,
0.00034912318,
-0.0067233015,
-0.04525457,
-0.02854886,
-0.040779825,
0.0... |
Great, no additional time is spent recomputing the same key and values for the attention layer! There is however one catch. While the required peak memory for the \( \mathbf{QK}^T \) matrix is significantly reduced, holding the key-value cache in memory can become very memory expensive for long input sequences or mul... |
[
0.0049909144,
0.03603411,
-0.005470247,
0.011167354,
-0.027164625,
-0.014087259,
0.00005468532,
-0.002707681,
-0.009235387,
0.009132935,
0.039254054,
-0.043586344,
0.030413842,
-0.02296406,
-0.034248505,
0.00881094,
-0.013809172,
-0.028847778,
-0.028833142,
-0.012982232,
0.05... | By using a single head-value projection weight pair, the key value vectors \( \mathbf{k}_i, \mathbf{v}_i \) have to be identical across all attention heads which in turn means that we only need to store 1 key-value projection pair in the cache instead of n_head ones. |
[
0.03929421,
0.014444669,
-0.0010476616,
0.039235342,
-0.051067755,
0.03505573,
0.0053643216,
-0.002805415,
-0.026725948,
0.04220816,
0.043208912,
0.00033205078,
-0.020618422,
-0.03190631,
-0.024430107,
0.0010789351,
0.011464491,
-0.051362094,
-0.04629947,
-0.02086861,
0.03876... |
As most LLMs use between 20 and 100 attention heads, MQA significantly reduces the memory consumption of the key-value cache. For the LLM used in this notebook we could therefore reduce the required memory consumption from 15 GB to less than 400 MB at an input sequence length of 16000.
In addition to memory savings, ... |
[
0.020444509,
0.025570115,
0.021646274,
-0.005806125,
-0.0086512705,
-0.004445088,
-0.0023962935,
0.032230508,
0.08652718,
0.020792007,
-0.021921378,
-0.007011511,
-0.0009121842,
0.008839499,
0.008470282,
0.039759647,
0.009404184,
-0.038977776,
-0.005617896,
0.0013809454,
-0.0... | Falcon
PaLM
MPT
BLOOM |
[
0.05756741,
0.004965784,
-0.022479836,
0.052988183,
-0.045138083,
-0.006441395,
0.01278615,
-0.013693075,
0.021112015,
0.029898776,
0.031459875,
-0.00882393,
-0.010035641,
-0.045257024,
-0.019565783,
0.028189,
-0.0073408857,
-0.028768837,
-0.006694144,
-0.011195315,
0.0350578... |
Also, the checkpoint used in this notebook - bigcode/octocoder - makes use of MQA.
3.2.3 Grouped-Query-Attention (GQA)
Grouped-Query-Attention, as proposed by Ainslie et al. from Google, found that using MQA can often lead to quality degradation compared to using vanilla multi-key-value head projections. The paper ar... |
[
0.049429305,
0.01167819,
0.005927678,
0.07972469,
-0.03271665,
0.020492198,
-0.0023862042,
-0.03413398,
0.018513843,
0.03862218,
0.02658966,
0.0025947434,
-0.023223506,
-0.048602533,
0.001062073,
0.017554196,
-0.042017862,
-0.033277676,
-0.042135973,
-0.006023643,
0.050935216... | As a conclusion, it is strongly recommended to make use of either GQA or MQA if the LLM is deployed with auto-regressive decoding and is required to handle large input sequences as is the case for example for chat. |
[
0.043452755,
0.049551878,
-0.06093504,
-0.015683465,
0.0057969796,
-0.015739677,
0.015037014,
0.0022221755,
0.0046235304,
0.023651676,
0.00007377974,
-0.015908318,
0.04873679,
-0.028949765,
-0.00042379435,
-0.010919401,
0.013708978,
-0.0286687,
-0.071109615,
-0.01960433,
0.00... |
Contribute to 🤗 Transformers
Everyone is welcome to contribute, and we value everybody's contribution. Code
contributions are not the only way to help the community. Answering questions, helping
others, and improving the documentation are also immensely valuable.
It also helps us if you spread the word! Reference the... |
[
0.074712306,
0.016065456,
-0.02169486,
0.032621678,
0.0030420437,
-0.014520978,
0.026097342,
0.0060010897,
-0.0010762628,
0.026169514,
0.02572205,
0.016325274,
-0.00013013488,
-0.058690153,
-0.0036879817,
0.018533733,
0.010760824,
-0.038077872,
-0.019991605,
0.022459881,
0.02... |
Conclusion
The research community is constantly coming up with new, nifty ways to speed up inference time for ever-larger LLMs. As an example, one such promising research direction is speculative decoding where "easy tokens" are generated by smaller, faster language models and only "hard tokens" are generated by the ... |
[
0.008852776,
-0.0069390144,
-0.04408162,
-0.018760076,
-0.011703892,
-0.012895111,
0.00134419,
0.007974008,
0.03686921,
0.055303816,
-0.0025891117,
0.016677069,
0.04527935,
-0.0167682,
-0.016807256,
0.03504658,
0.01580481,
-0.004149739,
-0.060250957,
0.015895942,
-0.007153824... |
If you don't know where to start, there is a special Good First
Issue listing. It will give you a list of
open issues that are beginner-friendly and help you start contributing to open-source. The best way to do that is to open a Pull Request and link it to the issue that you'd like to work on. We try to give priorit... |
[
-0.014583632,
0.06875335,
-0.04650483,
0.041159756,
-0.028977338,
-0.009977917,
0.03920623,
0.0033881508,
0.018843409,
0.02124462,
0.019765908,
0.016292969,
0.017717417,
-0.04590792,
-0.03513638,
-0.029411456,
-0.020973299,
-0.025450135,
-0.012535141,
0.003201616,
-0.00473120... | All contributions are equally valuable to the community. 🥰 |
[
0.0030392152,
-0.00812903,
-0.042405948,
-0.0096037,
0.0004310293,
-0.002958512,
0.022714328,
-0.0036866763,
0.031694412,
0.030432504,
-0.009420283,
-0.007608126,
0.026382662,
-0.030637931,
-0.00583632,
0.0053631053,
0.031665064,
-0.023095835,
-0.053645726,
-0.008004306,
0.00... |
Fixing outstanding issues
If you notice an issue with the existing code and have a fix in mind, feel free to start contributing and open a Pull Request!
Submitting a bug-related issue or feature request
Do your best to follow these guidelines when submitting a bug-related issue or a feature
request. It will make it e... |
[
0.002438011,
-0.012305987,
-0.06710846,
-0.023366148,
0.006890107,
-0.010340351,
0.0005597563,
0.008291661,
0.049307004,
0.041859735,
0.00009057108,
0.005464329,
0.026840616,
-0.027325105,
0.017607667,
0.014714583,
-0.025165673,
-0.05836,
-0.068105124,
-0.018659696,
0.0052359... | Fix outstanding issues with the existing code.
Submit issues related to bugs or desired new features.
Implement new models.
Contribute to the examples or to the documentation. |
[
0.03403366,
-0.0041458425,
-0.048128128,
-0.0140035795,
-0.008955859,
-0.039934322,
0.01911422,
0.03311081,
-0.017729944,
0.037920825,
-0.0009001302,
-0.0015922692,
0.040773276,
-0.05408472,
-0.01459784,
0.023001386,
0.0056664506,
-0.022833595,
-0.03853606,
-0.01062678,
-0.00... | python src/transformers/commands/transformers_cli.py env
Do you want a new feature?
If there is a new feature you'd like to see in 🤗 Transformers, please open an issue and describe:
What is the motivation behind this feature? Is it related to a problem or frustration with the library? Is it a feature related to somet... |
[
0.041662846,
-0.025403839,
-0.028788254,
-0.011251455,
-0.01174185,
0.0112652695,
0.0025279513,
0.012833151,
0.042988986,
0.035916246,
0.018980356,
0.012639756,
0.002550399,
0.005636088,
-0.0006881069,
0.03536369,
0.028954022,
-0.051968046,
-0.05205093,
-0.01805482,
-0.036358... | Whatever it is, we'd love to hear about it!
Describe your requested feature in as much detail as possible. The more you can tell us about it, the better we'll be able to help you.
Provide a code snippet that demonstrates the features usage.
If the feature is related to a paper, please include a link. |
[
0.018947687,
-0.006445722,
-0.030484721,
-0.015509032,
0.021768786,
-0.0031228594,
0.029642602,
0.005143946,
0.029249614,
0.07146787,
0.030288227,
-0.0016377468,
0.004126385,
-0.015424821,
0.029418038,
0.07595917,
-0.0035562,
-0.055860586,
-0.06029575,
0.015059901,
-0.0299794... | If your issue is well written we're already 80% of the way there by the time you create it.
We have added templates to help you get started with your issue.
Do you want to implement a new model?
New models are constantly released and if you want to implement a new model, please provide the following information:
A sho... |
[
0.0012038288,
-0.015631255,
-0.054642715,
-0.0062747262,
-0.0114604505,
-0.013401393,
0.009171324,
-0.0009899177,
0.0051931324,
0.047560498,
0.027780665,
-0.0040856097,
0.058554232,
-0.04652335,
-0.0332479,
0.012008655,
-0.007956382,
0.003680012,
-0.053220347,
0.011104858,
0.... | Your OS type and version and Python, PyTorch and
TensorFlow versions when applicable.
A short, self-contained, code snippet that allows us to reproduce the bug in
less than 30s.
The full traceback if an exception is raised.
Attach any other additional information, like screenshots, you think may help.
To get the O... |
[
0.0112865055,
0.035269454,
-0.026641484,
-0.06200914,
-0.006695444,
-0.033950705,
0.02762353,
0.01742429,
0.016807003,
0.012927924,
-0.021576937,
0.0059027933,
0.058586013,
-0.024242489,
0.017648757,
0.018223954,
0.0069199116,
-0.026739689,
-0.07042667,
-0.003675655,
0.002318... | Fork the repository by
clicking on the Fork button on the repository's page. This creates a copy of the code
under your GitHub user account.
Clone your fork to your local disk, and add the base repository as a remote:
git clone git@github.com:<your Github handle>/transformers.git
cd transformers
git re... |
[
0.029616058,
-0.009798825,
-0.043861408,
-0.048280485,
-0.0042166514,
-0.02006426,
0.022191457,
0.024510788,
0.010183093,
0.021601332,
0.0063061067,
-0.014341418,
0.03277254,
-0.03576434,
-0.028051538,
0.03645053,
-0.0026744343,
0.0105879465,
-0.033568524,
-0.0027996644,
-0.0... | To get the OS and software versions automatically, run the following command:
transformers-cli env
You can also run the same command from the root of the repository:
python src/transformers/commands/transformers_cli.py env
Do you want a new feature?
If there is a new feature you'd like to see in 🤗 Transformers, plea... |
[
0.035950214,
0.020979982,
-0.0016877042,
-0.027937215,
-0.055982713,
-0.030887946,
0.0053025214,
0.016540347,
0.025663255,
0.055224728,
-0.052003283,
0.003722255,
0.060043354,
-0.02206282,
0.015701147,
0.007701684,
-0.017880358,
-0.026326492,
-0.08126698,
0.019815931,
0.01712... | pip install -e ".[quality]"
which should be enough for most use cases.
Develop the features in your branch.
As you work on your code, you should make sure the test suite
passes. Run the tests impacted by your changes like this: |
[
0.052693456,
0.0067152567,
-0.020880481,
-0.038704563,
-0.026111621,
0.0072662896,
0.016119555,
0.011505571,
0.010712083,
0.022070711,
-0.03747025,
-0.030828465,
0.056161292,
-0.024245456,
-0.0010194113,
0.017442035,
-0.019602085,
0.0050107273,
-0.06483088,
0.022952365,
-0.00... | Develop the features in your branch.
As you work on your code, you should make sure the test suite
passes. Run the tests impacted by your changes like this:
pytest tests/<TEST_TO_RUN>.py
For more information about tests, check out the
Testing guide.
🤗 Transformers relies on black and ruff to format its sour... |
[
0.057086088,
0.0011733891,
-0.04091311,
-0.03554097,
0.0074997945,
-0.028642004,
0.027101047,
0.008849898,
0.016074017,
0.054937232,
0.0014764557,
-0.025376307,
0.036049906,
-0.026323501,
0.016950525,
0.03582371,
0.021432023,
-0.0377181,
-0.07634098,
-0.029716434,
0.011854057... |
If you are willing to contribute the model yourself, let us know so we can help you add it to 🤗 Transformers!
We have added a detailed guide and templates to help you get started with adding a new model, and we also have a more technical guide for how to add a model to 🤗 Transformers.
Do you want to add documentati... |
[
0.018068524,
-0.00014487194,
0.0055362633,
-0.022022452,
-0.032765485,
-0.03868105,
0.026635366,
-0.0039271074,
0.017961247,
0.0129575385,
0.027355654,
0.029577823,
0.046098493,
-0.036443554,
-0.0029922642,
0.007915515,
0.011233442,
0.037792183,
-0.057898972,
0.030068232,
0.0... | make fixup
This target is also optimized to only work with files modified by the PR you're working on.
If you prefer to run the checks one after the other, the following command applies the
style corrections:
make style
🤗 Transformers also uses ruff and a few custom scripts to check for coding mistakes. Quality... |
[
-0.006578123,
-0.013983331,
-0.0023708579,
-0.015266012,
-0.013366522,
-0.042027093,
0.02270977,
0.024714397,
-0.0005283176,
0.047185857,
0.013878193,
0.004247568,
0.058765035,
0.009013816,
-0.0028912902,
-0.022331273,
-0.014789388,
-0.0015008424,
-0.09095123,
0.031064723,
-0... | Create a new branch to hold your development changes:
git checkout -b a-descriptive-name-for-my-changes
🚨 Do not work on the main branch!
Set up a development environment by running the following command in a virtual environment: |
[
0.030441662,
-0.0005453231,
-0.010622952,
-0.055452272,
-0.022619097,
-0.045762785,
0.014063647,
-0.009033753,
0.0076759895,
0.034067508,
0.034437805,
0.0422758,
0.02960849,
-0.05711862,
0.00445516,
0.011016395,
0.020906463,
0.0274947,
-0.04514562,
0.024285443,
0.022094507,
... | make style
🤗 Transformers also uses ruff and a few custom scripts to check for coding mistakes. Quality
controls are run by the CI, but you can run the same checks with:
make quality
Finally, we have a lot of scripts to make sure we don't forget to update
some files when adding a new model. You can run these... |
[
-0.012752787,
-0.008581112,
-0.039050907,
0.014431544,
-0.025519984,
-0.029770913,
-0.021715762,
-0.018329429,
0.0019921726,
0.039166186,
-0.0085018575,
0.00032647495,
0.0683607,
-0.07435523,
-0.010166205,
0.03199004,
-0.006297139,
-0.021802222,
-0.04841736,
-0.011362229,
0.0... | pip install -e ".[dev]"
If 🤗 Transformers was already installed in the virtual environment, remove
it with pip uninstall transformers before reinstalling it in editable
mode with the -e flag.
Depending on your OS, and since the number of optional dependencies of Transformers is growing, you might get a
failur... |
[
0.012926784,
0.0041340766,
-0.011224734,
-0.048625838,
-0.012178469,
-0.04049708,
0.013000149,
0.0048530465,
0.027203472,
0.087684974,
-0.030138044,
-0.0024136845,
0.03198682,
-0.027526274,
-0.03721036,
0.009728102,
0.022537503,
-0.0041487496,
-0.043050155,
0.00089366856,
0.0... | make repo-consistency
To learn more about those checks and how to fix any issues with them, check out the
Checks on a Pull Request guide.
If you're modifying documents under the docs/source directory, make sure the documentation can still be built. This check will also run in the CI when you open a pull request. To ... |
[
0.022370163,
-0.0072077666,
-0.020812115,
-0.04468315,
-0.026529728,
-0.030303353,
0.01047038,
0.006639579,
0.019511357,
0.04176717,
-0.035306264,
0.00048108358,
0.04305363,
-0.014315476,
0.048771244,
0.036907196,
0.014708562,
-0.03319075,
-0.058548365,
0.012357193,
-0.043053... | pip install ".[docs]"
Run the following command from the root of the repository:
doc-builder build transformers docs/source/en --build_dir ~/tmp/test-build
This will build the documentation in the ~/tmp/test-build folder where you can inspect the generated
Markdown files with your favorite editor. You can also p... |
[
0.008983136,
0.015150158,
-0.03281857,
-0.014852299,
0.0025757975,
-0.05908426,
0.017275782,
0.003753692,
0.018318286,
0.066016234,
-0.03555345,
-0.012543897,
0.03625748,
0.009937637,
-0.012178344,
-0.03804463,
0.0026197992,
-0.04364978,
-0.04987773,
-0.0050568217,
0.00266887... | git add modified_file.py
git commit
Please remember to write good commit
messages to clearly communicate the changes you made!
To keep your copy of the code up to date with the original
repository, rebase your branch on upstream/branch before you open a pull request or if requested by a maintainer:
git fet... |
[
-0.0125360275,
-0.0037186064,
-0.017544905,
-0.030523704,
0.008896982,
-0.024864504,
0.0270507,
0.031547617,
0.0054966193,
0.08401629,
0.009893223,
0.0024975198,
0.022111006,
-0.015178832,
-0.009353592,
0.0013819379,
0.0029195384,
-0.009554224,
-0.046131473,
-0.0060189534,
-0... | git fetch upstream
git rebase upstream/main
Push your changes to your branch:
git push -u origin a-descriptive-name-for-my-changes
If you've already opened a pull request, you'll need to force push with the --force flag. Otherwise, if the pull request hasn't been opened yet, you can just push your changes normal... |
[
0.050044328,
-0.010515449,
0.0127204135,
-0.018504957,
-0.03153937,
0.025761804,
-0.00064151565,
-0.0041971086,
-0.0013449587,
0.07262428,
0.0012725648,
-0.034721218,
0.03273954,
-0.027576014,
0.001985166,
0.028720364,
-0.020849477,
0.038433373,
-0.017793229,
0.002841683,
-0.... | python -m pytest -n auto --dist=loadfile -s -v ./tests/models/my_new_model
Similarly, for the examples directory, specify a path to a subfolder or test file to run the test. For example, the following command tests the text classification subfolder in the PyTorch examples directory: |
[
0.035035897,
-0.015823996,
-0.018068828,
-0.023012966,
-0.03294256,
0.006944517,
-0.00499234,
-0.0011336055,
-0.009103274,
0.056575265,
0.01305583,
-0.019721465,
0.05326999,
-0.04390505,
0.006180173,
0.022365684,
-0.027530173,
-0.024335075,
-0.047568392,
-0.006555459,
-0.0116... |
pip install -r examples/xxx/requirements.txt # only needed the first time
python -m pytest -n auto --dist=loadfile -s -v ./examples/pytorch/text-classification
In fact, this is actually how our make test and make test-examples commands are implemented (not including the pip install)!
You can also specify a smaller s... |
[
0.061730225,
0.028346077,
0.01889277,
0.00549136,
-0.026989672,
0.015723214,
0.00019528586,
0.0030294177,
0.018505227,
0.058020875,
0.019875472,
-0.0037785543,
0.041688662,
-0.052650623,
0.002017305,
0.007854687,
0.0066747535,
-0.0037058897,
-0.040276896,
0.014934286,
-0.0058... | Remember to specify a path to a subfolder or a test file to run the test. Otherwise, you'll run all the tests in the tests or examples folder, which will take a very long time! |
[
0.03431688,
-0.009987092,
-0.016703814,
-0.021572705,
-0.018844953,
0.05033142,
-0.015075962,
-0.01954889,
-0.013191467,
0.036839318,
-0.034082234,
-0.0053968425,
0.04496391,
-0.06218101,
-0.01627852,
-0.0046855737,
-0.0058038053,
-0.0011035663,
-0.047017056,
0.015105293,
-0.... |
RUN_SLOW=yes python -m pytest -n auto --dist=loadfile -s -v ./tests/models/my_new_model
RUN_SLOW=yes python -m pytest -n auto --dist=loadfile -s -v ./examples/pytorch/text-classification
Like the slow tests, there are other environment variables available which not enabled by default during testing:
- RUN_CUSTOM_TOKE... |
[
-0.0049829716,
0.006124688,
-0.028666703,
-0.017359586,
-0.005254645,
-0.015378778,
0.014278329,
0.017043207,
0.014237062,
0.06399112,
0.00014454142,
0.0012680958,
0.0585439,
-0.036369845,
-0.03265583,
-0.0067093014,
0.026933495,
-0.030977646,
-0.061570134,
0.006891563,
0.003... | Now you can go to your fork of the repository on GitHub and click on Pull Request to open a pull request. Make sure you tick off all the boxes on our checklist below. When you're ready, you can send your changes to the project maintainers for review.
It's ok if maintainers request changes, it happens to our core contr... |
[
0.04240985,
-0.0022290538,
-0.005745176,
-0.02071248,
-0.0024081243,
0.008349159,
0.022667332,
-0.0022346498,
0.0070098615,
0.0481401,
-0.049333904,
-0.014049568,
0.022085354,
-0.05196027,
-0.041096665,
0.010512927,
0.03205361,
-0.022786712,
-0.06171961,
-0.023905903,
0.00376... |
Pull request checklist
☐ The pull request title should summarize your contribution.
☐ If your pull request addresses an issue, please mention the issue number in the pull
request description to make sure they are linked (and people viewing the issue know you
are working on it).
☐ To indicate a work in progress please... |
[
-0.009272061,
0.022390878,
-0.028367909,
-0.008452135,
-0.017103504,
-0.03892733,
0.021808501,
0.0049118935,
0.023463678,
0.047479082,
-0.015455989,
-0.028996263,
0.048245367,
-0.035187855,
-0.02191578,
-0.0045479075,
0.016980898,
-0.05719559,
-0.056276046,
0.01015329,
-0.005... | You can now use make from any terminal (PowerShell, cmd.exe, etc.)! 🎉
Sync a forked repository with upstream main (the Hugging Face repository)
When updating the main branch of a forked repository, please follow these steps to avoid pinging the upstream repository which adds reference notes to each upstream PR, and se... |
[
-0.021145724,
0.02591834,
-0.021159519,
0.0041208644,
-0.004451913,
-0.044332914,
0.029932303,
0.00330014,
0.019311164,
0.06323027,
-0.052885003,
-0.030070242,
0.022745792,
-0.014855803,
-0.042208686,
0.0013293667,
0.012903996,
-0.030732337,
-0.07663774,
-0.0039243046,
0.0005... | When possible, avoid syncing with the upstream using a branch and PR on the forked repository. Instead, merge directly into the forked main.
If a PR is absolutely necessary, use the following steps after checking out your branch:
git checkout -b your-branch-for-syncing
git pull --squash --no-commit upstream main... |
[
0.0113703795,
-0.022556795,
-0.011568494,
-0.033424813,
-0.048396636,
-0.03523615,
0.005140374,
0.00031088118,
0.01968413,
0.050377786,
-0.017519018,
0.019103935,
0.054849524,
-0.014214744,
-0.009099134,
0.010691129,
0.012955299,
0.00022862812,
-0.038236175,
0.0345569,
0.0015... | python -m unittest discover -s tests -t . -v
python -m unittest discover -s examples -t examples -v
Style guide
For documentation strings, 🤗 Transformers follows the Google Python Style Guide.
Check our documentation writing guide
for more information.
Develop on Windows
On Windows (unless you're working in Windows Su... |
[
0.035399973,
0.023936989,
-0.019807465,
-0.011156829,
-0.022655413,
-0.009469422,
-0.043659016,
0.02228518,
0.031014135,
0.064762294,
-0.012303128,
-0.02069033,
0.0265571,
-0.060034707,
-0.019665068,
0.00092558254,
0.004627913,
-0.013214471,
-0.022100063,
0.045168426,
0.03189... | git config core.autocrlf input
One way to run the make command on Windows is with MSYS2:
Download MSYS2, and we assume it's installed in C:\msys64.
Open the command line C:\msys64\msys2.exe (it should be available from the Start menu).
Run in the shell: pacman -Syu and install make with pacman -S make.
Add C:\msys64\u... |
[
0.027390253,
0.002373423,
-0.047742926,
-0.0015271544,
-0.045603503,
-0.0012218994,
-0.04157801,
0.014215907,
0.023209931,
0.08332492,
0.0065766163,
-0.023181781,
0.0023857388,
-0.04411154,
-0.0051761386,
0.024504846,
-0.00831138,
-0.028276987,
-0.064520516,
-0.016467933,
0.0... | Pipelines for inference
The [pipeline] makes it simple to use any model from the Hub for inference on any language, computer vision, speech, and multimodal tasks. Even if you don't have experience with a specific modality or aren't familiar with the underlying code behind the models, you can still use them for inferenc... |
[
0.04273485,
0.0015727022,
-0.033295084,
0.0097169895,
-0.03429024,
-0.003905988,
-0.031361636,
0.01804076,
0.030195883,
0.092976026,
0.006425866,
-0.031816565,
0.022661129,
-0.03576876,
0.014152543,
0.041654397,
-0.022135118,
-0.052345216,
-0.067443155,
-0.014216517,
0.019533... | Use a [pipeline] for inference.
Use a specific tokenizer or model.
Use a [pipeline] for audio, vision, and multimodal tasks.
Take a look at the [pipeline] documentation for a complete list of supported tasks and available parameters. |
[
0.019415613,
-0.0033658454,
-0.01781418,
0.011458047,
0.00070239883,
0.0036776292,
-0.03313409,
-0.0098424405,
0.011365929,
0.07998666,
0.03489142,
-0.029874535,
0.0017830124,
-0.037073903,
-0.011996582,
0.044726774,
-0.03953983,
-0.027266892,
-0.07346755,
-0.016567046,
0.016... | Take a look at the [pipeline] documentation for a complete list of supported tasks and available parameters.
Pipeline usage
While each task has an associated [pipeline], it is simpler to use the general [pipeline] abstraction which contains
all the task-specific pipelines. The [pipeline] automatically loads a default... |
[
0.018035062,
0.0127238585,
-0.043756254,
-0.005145678,
-0.004199305,
0.006034477,
-0.027174937,
0.017473714,
0.01593361,
0.037883706,
0.019618347,
-0.031780858,
0.015429838,
-0.027304478,
-0.009852354,
0.048650045,
-0.03474592,
-0.037595835,
-0.01232084,
-0.026095424,
-0.0086... | Start by creating a [pipeline] and specify the inference task:
from transformers import pipeline
transcriber = pipeline(task="automatic-speech-recognition")
Pass your input to the [pipeline]. In the case of speech recognition, this is an audio input file:
transcriber("https://huggingface.co/datasets/Narsil/asr_dummy... |
[
0.02772043,
0.021773342,
-0.028056268,
0.029077766,
0.0017718828,
-0.029777424,
-0.020443993,
0.0018575907,
0.026433062,
0.03131667,
0.023648424,
0.011656295,
-0.0072694416,
-0.048472274,
-0.03397537,
0.012376942,
0.009221487,
-0.03215626,
-0.05591663,
-0.019590411,
0.0223610... |
Not the result you had in mind? Check out some of the most downloaded automatic speech recognition models
on the Hub to see if you can get a better transcription.
Let's try the Whisper large-v2 model from OpenAI. Whisper was released
2 years later than Wav2Vec2, and was trained on close to 10x more data. As such, i... |
[
0.033880055,
0.032580234,
-0.033936568,
-0.00010590828,
-0.03421914,
-0.019596178,
-0.024216184,
0.0049061086,
0.012129285,
0.054903205,
0.0074245073,
-0.008236893,
0.029358946,
-0.027169034,
-0.0146370875,
0.015089198,
-0.010596347,
-0.025346462,
-0.07273333,
-0.035349414,
0... |
Now this result looks more accurate! For a deep-dive comparison on Wav2Vec2 vs Whisper, refer to the Audio Transformers Course.
We really encourage you to check out the Hub for models in different languages, models specialized in your field, and more.
You can check out and compare model results directly from your bro... |
[
0.01754554,
0.0041935383,
-0.023380028,
0.03385686,
-0.007636728,
-0.015750313,
-0.03688631,
0.0215287,
0.0010781882,
0.053183604,
0.035231333,
0.030883517,
-0.013983137,
-0.0082818875,
-0.031528678,
0.066030696,
-0.020897565,
-0.033912964,
-0.074389726,
-0.0008401979,
0.0138... | transcriber = pipeline(model="openai/whisper-large-v2", my_parameter=1)
out = transcriber() # This will use my_parameter=1.
out = transcriber(, my_parameter=2) # This will override and use my_parameter=2.
out = transcriber() # This will go back to using my_parameter=1. |
[
0.010512585,
-0.018863307,
-0.01882092,
0.05151732,
0.017775312,
-0.024614144,
0.0040093362,
0.019244812,
0.027750963,
-0.009177317,
0.01636233,
0.00624538,
0.019711098,
-0.023950042,
-0.021745792,
0.038913522,
-0.02108169,
-0.019456761,
-0.013522237,
0.010710402,
-0.00391749... | transcriber = pipeline(model="openai/whisper-large-v2")
transcriber("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")
{'text': ' I have a dream that one day this nation will rise up and live out the true meaning of its creed.'} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.