vector listlengths 1.02k 1.02k | text stringlengths 2 11.8k |
|---|---|
[
-0.021061942,
-0.030300146,
-0.006899602,
-0.02768556,
-0.027336948,
0.019507715,
0.024010614,
-0.0035187968,
-0.042269137,
0.061878532,
0.039480247,
-0.007894597,
0.024765939,
-0.05020005,
-0.0022932098,
0.058072858,
-0.030358247,
-0.012891361,
-0.06885076,
0.009267255,
-0.0... | tf_model = TFDistilBertModel.from_pretrained("distilbert/distilbert-base-uncased")
When you load pretrained weights, the default model configuration is automatically loaded if the model is provided by 🤗 Transformers. However, you can still replace - some or all of - the default model configuration attributes with you... |
[
0.006338775,
-0.03507994,
-0.026486238,
-0.03745974,
0.00673908,
-0.032935187,
-0.007278941,
0.00796203,
-0.05185603,
0.0852613,
0.0317306,
0.015248316,
0.04891801,
-0.03913441,
-0.017657492,
0.042131186,
-0.00158653,
-0.0026717607,
-0.070042364,
-0.0005237936,
0.018671108,
... | tf_model = TFDistilBertModel.from_pretrained("distilbert/distilbert-base-uncased", config=my_config)
Model heads
At this point, you have a base DistilBERT model which outputs the hidden states. The hidden states are passed as inputs to a model head to produce the final output. 🤗 Transformers provides a different mode... |
[
-0.012134597,
-0.017637158,
0.009607762,
-0.033276018,
0.027976181,
0.008753417,
-0.010751716,
-0.04257245,
0.0035639948,
0.085608274,
0.019852662,
-0.010708274,
0.034637176,
-0.028830526,
-0.0051586516,
0.014538347,
-0.04352816,
-0.023168681,
-0.06817384,
-0.032812644,
0.013... | For example, [DistilBertForSequenceClassification] is a base DistilBERT model with a sequence classification head. The sequence classification head is a linear layer on top of the pooled outputs.
from transformers import DistilBertForSequenceClassification
model = DistilBertForSequenceClassification.from_pretrained("d... |
[
0.0022963404,
-0.02746748,
-0.005043088,
-0.027142595,
-0.0011204812,
0.01721886,
-0.016864441,
-0.0072508235,
-0.04055145,
0.08689175,
0.0016973352,
-0.0005925444,
0.029534923,
-0.00008277855,
-0.021073168,
0.017307466,
-0.037686564,
-0.023376891,
-0.052276816,
-0.026906315,
... | from transformers import DistilBertForQuestionAnswering
model = DistilBertForQuestionAnswering.from_pretrained("distilbert/distilbert-base-uncased")
``
</pt>
<tf>
For example, [TFDistilBertForSequenceClassification`] is a base DistilBERT model with a sequence classification head. The sequence classification head is a l... |
[
0.0030172116,
-0.019865278,
-0.017191386,
-0.013514783,
-0.014750005,
0.013391261,
0.0076147807,
-0.0037310973,
-0.040747795,
0.079344854,
-0.021449268,
-0.0011334979,
0.026448285,
-0.014750005,
0.0048246323,
0.01399434,
-0.023556411,
-0.036126614,
-0.042520706,
-0.0118508665,
... | from transformers import TFDistilBertForQuestionAnswering
tf_model = TFDistilBertForQuestionAnswering.from_pretrained("distilbert/distilbert-base-uncased")
Tokenizer
The last base class you need before using a model for textual data is a tokenizer to convert raw text to tensors. There are two types of tokenizers you c... |
[
0.0020017396,
0.007427144,
-0.040476553,
0.009187294,
-0.014122617,
-0.010119138,
0.024614492,
-0.023247788,
-0.03191739,
0.050361004,
0.0004931009,
-0.018457418,
0.018843962,
-0.058920167,
0.00822784,
-0.009187294,
-0.040725045,
-0.050857987,
-0.048842445,
0.02341345,
0.0017... | [PreTrainedTokenizer]: a Python implementation of a tokenizer.
[PreTrainedTokenizerFast]: a tokenizer from our Rust-based 🤗 Tokenizer library. This tokenizer type is significantly faster - especially during batch tokenization - due to its Rust implementation. The fast tokenizer also offers additional methods like offs... |
[
0.017098373,
-0.005222501,
-0.033245236,
0.007475132,
0.0140492115,
0.008239225,
0.032639727,
-0.011194677,
-0.008469894,
0.07796627,
0.012362441,
0.01820847,
0.03318757,
-0.06164641,
0.015757607,
0.008938441,
-0.006325389,
-0.040136486,
-0.056427516,
0.010192706,
-0.00506391... | Both tokenizers support common methods such as encoding and decoding, adding new tokens, and managing special tokens.
Not every model supports a fast tokenizer. Take a look at this table to check if a model has fast tokenizer support.
If you trained your own tokenizer, you can create one from your vocabulary file:
f... |
[
0.005515011,
-0.029118659,
-0.01807365,
-0.011000049,
-0.011015035,
0.011359723,
-0.035098247,
-0.012730983,
-0.03198107,
0.08308484,
0.028639091,
-0.024382941,
0.033269905,
-0.02974809,
-0.026780773,
0.026840718,
-0.032670446,
-0.03458871,
-0.041062854,
-0.021640424,
0.02423... | from transformers import DistilBertForSequenceClassification
model = DistilBertForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
Easily reuse this checkpoint for another task by switching to a different model head. For a question answering task, you would use the [DistilBertForQuestionAns... |
[
-0.004762355,
-0.0064211935,
-0.025118519,
-0.017670078,
-0.018991342,
-0.005920275,
0.009531969,
-0.0030526984,
-0.030606842,
0.07503612,
0.03429476,
0.015898716,
0.015869677,
-0.061329838,
-0.00021370704,
0.024319952,
-0.01925269,
-0.056277096,
-0.06638258,
0.004010977,
-0.... | It is important to remember the vocabulary from a custom tokenizer will be different from the vocabulary generated by a pretrained model's tokenizer. You need to use a pretrained model's vocabulary if you are using a pretrained model, otherwise the inputs won't make sense. Create a tokenizer with a pretrained model's v... |
[
0.008568868,
-0.024440413,
-0.026825562,
0.007004534,
-0.013272911,
0.00018760501,
-0.036483943,
-0.004796063,
-0.03998805,
0.083097406,
0.013898645,
-0.012647177,
0.043256585,
-0.03144863,
-0.02498517,
0.016872719,
-0.034128238,
-0.036542833,
-0.044699453,
-0.034246024,
0.01... | from transformers import TFDistilBertForSequenceClassification
tf_model = TFDistilBertForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
Easily reuse this checkpoint for another task by switching to a different model head. For a question answering task, you would use the [TFDistilBertForQu... |
[
0.018704649,
-0.010271048,
0.008835542,
-0.044931352,
-0.013881347,
-0.0068940194,
-0.024561515,
0.014914911,
-0.048290435,
0.05762123,
0.007550764,
-0.026642999,
0.04246228,
-0.033849243,
0.0031796468,
0.05552539,
0.0116922,
-0.057477675,
-0.043151323,
0.01805867,
-0.0191209... | from transformers import ViTImageProcessor
vit_extractor = ViTImageProcessor()
print(vit_extractor)
ViTImageProcessor {
"do_normalize": true,
"do_resize": true,
"image_processor_type": "ViTImageProcessor",
"image_mean": [
0.5,
0.5,
0.5
],
"image_std": [
0.5,
0.5,
0.5
],
"resample... |
[
0.014160917,
-0.02230621,
-0.0021313978,
-0.05481824,
-0.0009905036,
-0.029068602,
-0.01611081,
0.01904256,
-0.010994071,
0.04519324,
0.013953482,
-0.018890442,
0.040989216,
-0.03570653,
0.017258618,
0.040159475,
0.0136285,
-0.079378575,
-0.059630737,
0.008809086,
-0.03097700... | If you aren't looking for any customization, just use the from_pretrained method to load a model's default image processor parameters.
Modify any of the [ViTImageProcessor] parameters to create your custom image processor: |
[
0.03743271,
-0.008703175,
-0.012479893,
-0.054769382,
0.008738016,
0.024555637,
-0.0106612155,
-0.011211696,
0.0038847239,
0.06460836,
0.05170341,
-0.038352504,
0.030018637,
-0.065611765,
0.023775207,
0.08947059,
-0.023482546,
-0.040554427,
-0.064887084,
-0.0021723097,
0.0160... |
Computer vision models consist of a backbone, neck, and head. The backbone extracts features from an input image, the neck combines and enhances the extracted features, and the head is used for the main task (e.g., object detection). Start by initializing a backbone in the model config and specify whether you want to... |
[
-0.012062713,
-0.0064798235,
-0.013969582,
-0.0043999236,
-0.017910443,
0.004541173,
-0.006359761,
-0.01054428,
-0.02730354,
0.08350674,
0.025947543,
-0.012557086,
0.034154143,
-0.04808135,
0.018418942,
0.025665045,
-0.014944203,
-0.051782086,
-0.05517208,
0.015608076,
-0.033... | from transformers import DistilBertTokenizer
slow_tokenizer = DistilBertTokenizer.from_pretrained("distilbert/distilbert-base-uncased")
Create a fast tokenizer with the [DistilBertTokenizerFast] class:
from transformers import DistilBertTokenizerFast
fast_tokenizer = DistilBertTokenizerFast.from_pretrained("distilber... |
[
0.02236729,
-0.0044345274,
-0.018686596,
-0.0057758573,
-0.008677942,
0.014524582,
-0.019620927,
-0.02256548,
-0.0099944975,
0.048811655,
0.045357466,
-0.038788844,
0.03808102,
-0.053171862,
0.03827921,
0.076501794,
-0.038420774,
-0.012061348,
-0.07208496,
0.013590252,
-0.002... | Set use_pretrained_backbone=True to load pretrained ResNet weights for the backbone.
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, ResNetConfig
config = MaskFormerConfig(backbone="microsoft/resnet50", use_pretrained_backbone=True) # backbone and neck config
model = MaskFormerForInstance... |
[
0.00877675,
-0.0069980617,
-0.010113419,
0.016223904,
-0.025092594,
-0.01850119,
0.0022083323,
0.0024417187,
-0.020806767,
0.06472588,
0.013267674,
-0.0048162504,
0.01934987,
-0.049647693,
0.0023250254,
0.025955418,
0.005180475,
-0.06795086,
-0.060199596,
-0.008670665,
-0.014... | By default, [AutoTokenizer] will try to load a fast tokenizer. You can disable this behavior by setting use_fast=False in from_pretrained.
Image processor
An image processor processes vision inputs. It inherits from the base [~image_processing_utils.ImageProcessingMixin] class.
To use, create an image processor associ... |
[
0.0040227375,
0.0030076061,
-0.023676096,
-0.04416423,
-0.011260917,
0.015953539,
-0.017712412,
-0.02522885,
-0.001514109,
0.059252072,
0.0565588,
-0.04355962,
0.039519705,
-0.060955983,
0.0112884,
0.044741362,
-0.03971208,
-0.02259054,
-0.0713993,
0.0011963436,
-0.00604613,
... | You could also load the backbone config separately and then pass it to the model config.
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, ResNetConfig
backbone_config = ResNetConfig.from_pretrained("microsoft/resnet-50")
config = MaskFormerConfig(backbone_config=backbone_config)
model = Ma... |
[
0.014009072,
0.005881431,
0.0038381498,
-0.039130237,
-0.022196192,
-0.026436701,
-0.035547495,
0.008991837,
-0.025345085,
0.072214596,
-0.015198654,
-0.015310614,
0.045959834,
-0.0309851,
-0.0016724117,
0.020614749,
-0.013911107,
-0.048003115,
-0.041929252,
0.016066348,
0.00... | from transformers import ViTImageProcessor
my_vit_extractor = ViTImageProcessor(resample="PIL.Image.BOX", do_normalize=False, image_mean=[0.3, 0.3, 0.3])
print(my_vit_extractor)
ViTImageProcessor {
"do_normalize": false,
"do_resize": true,
"image_processor_type": "ViTImageProcessor",
"image_mean": [
0.3,
... |
[
0.0012175957,
-0.009163435,
-0.032625858,
-0.03391478,
-0.0030309823,
0.013526975,
0.002404982,
-0.02305292,
0.006807123,
0.056390367,
0.04758273,
-0.035123143,
0.038667683,
-0.060364548,
0.016312929,
0.057518177,
-0.025442798,
-0.030692471,
-0.060740482,
0.0025123924,
0.0004... | You could also load the backbone config separately and then pass it to the model config.
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, ResNetConfig
backbone_config = ResNetConfig()
config = MaskFormerConfig(backbone_config=backbone_config)
model = MaskFormerForInstanceSegmentation(confi... |
[
0.012620855,
0.013773923,
-0.012725679,
-0.037541103,
-0.009168639,
0.0021681176,
-0.02696083,
-0.02262809,
-0.012739656,
0.066304915,
0.05322283,
-0.04299197,
0.04528413,
-0.04564752,
0.02503206,
0.051601548,
-0.052579906,
-0.015989212,
-0.07435542,
0.019050084,
-0.01255796,... | Set use_pretrained_backbone=False to randomly initialize a ResNet backbone.
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, ResNetConfig
config = MaskFormerConfig(backbone="microsoft/resnet50", use_pretrained_backbone=False) # backbone and neck config
model = MaskFormerForInstanceSegmenta... |
[
-0.029906245,
0.05724351,
-0.015958374,
-0.03155374,
0.015874604,
0.021263871,
-0.05255234,
-0.0015785596,
0.01958845,
0.06645832,
-0.0043630726,
-0.000059337788,
0.0076301415,
-0.057103895,
-0.012070004,
0.033480473,
0.016963627,
-0.072378136,
-0.050709374,
-0.065173835,
0.0... | Feature extractor
A feature extractor processes audio inputs. It inherits from the base [~feature_extraction_utils.FeatureExtractionMixin] class, and may also inherit from the [SequenceFeatureExtractor] class for processing audio inputs.
To use, create a feature extractor associated with the model you're using. For exa... |
[
0.0018676467,
0.056921363,
-0.008967439,
-0.021871801,
-0.0024178592,
0.007593616,
-0.041939177,
0.019534253,
-0.008653031,
0.041857157,
0.019944347,
-0.04303277,
0.037537478,
-0.051808827,
0.016185133,
0.058889825,
-0.0019325786,
-0.08147246,
-0.028023245,
-0.028406002,
-0.0... | Modify any of the [Wav2Vec2FeatureExtractor] parameters to create your custom feature extractor:
from transformers import Wav2Vec2FeatureExtractor
w2v2_extractor = Wav2Vec2FeatureExtractor(sampling_rate=8000, do_normalize=False)
print(w2v2_extractor)
Wav2Vec2FeatureExtractor {
"do_normalize": false,
"feature_extra... |
[
-0.00435291,
0.016869644,
-0.02368525,
-0.026693331,
-0.0019274752,
0.008780344,
-0.027275978,
0.022858705,
-0.0009230879,
0.046584606,
0.034199983,
-0.041869234,
0.032573994,
-0.068399966,
0.0067309197,
0.052871764,
0.011422577,
-0.068399966,
-0.047560196,
-0.028915517,
-0.0... | If you aren't looking for any customization, just use the from_pretrained method to load a model's default feature extractor parameters.
Modify any of the [Wav2Vec2FeatureExtractor] parameters to create your custom feature extractor: |
[
0.027584553,
-0.02530039,
-0.020761158,
-0.0014476071,
-0.02063022,
0.014155997,
-0.020601122,
-0.00074017094,
0.01731309,
0.055983838,
0.024529302,
-0.0038554359,
0.013232147,
-0.04897131,
0.027773688,
0.06919416,
0.004535593,
-0.028748458,
-0.0859544,
0.011464466,
0.0233072... | timm models are loaded with [TimmBackbone] and [TimmBackboneConfig].
thon
from transformers import TimmBackboneConfig, TimmBackbone
backbone_config = TimmBackboneConfig("resnet50")
model = TimmBackbone(config=backbone_config) |
[
0.01060271,
0.033244062,
-0.050823383,
-0.006432697,
0.016607527,
-0.010167577,
-0.013619622,
-0.005943174,
-0.0036496674,
0.049895104,
-0.014395608,
-0.03167759,
0.021190915,
-0.052215807,
0.015374654,
0.043194074,
-0.014373851,
-0.087722555,
-0.054797586,
-0.03301199,
-0.00... | Processor
For models that support multimodal tasks, 🤗 Transformers offers a processor class that conveniently wraps processing classes such as a feature extractor and a tokenizer into a single object. For example, let's use the [Wav2Vec2Processor] for an automatic speech recognition task (ASR). ASR transcribes audio t... |
[
0.0073352465,
0.0546292,
0.0039521502,
0.0014200329,
0.0042679063,
0.009424092,
-0.024483208,
0.007862663,
-0.009507368,
0.045857437,
-0.038806718,
-0.028105723,
0.023192426,
-0.061291296,
-0.0073421863,
0.03150617,
-0.026370801,
-0.09282522,
-0.044413984,
-0.03125634,
-0.031... | from transformers import Wav2Vec2FeatureExtractor
feature_extractor = Wav2Vec2FeatureExtractor(padding_value=1.0, do_normalize=True)
Create a tokenizer to handle the text inputs:
from transformers import Wav2Vec2CTCTokenizer
tokenizer = Wav2Vec2CTCTokenizer(vocab_file="my_vocab_file.txt")
Combine the feature extract... |
[
0.004474114,
0.042497072,
-0.0064692325,
-0.02603121,
-0.018134888,
0.009600411,
-0.039046813,
0.014586453,
-0.015526158,
0.049930554,
0.027279474,
-0.04375936,
0.033969607,
-0.052875895,
0.007510621,
0.072595656,
0.0012149534,
-0.06951006,
-0.034642827,
-0.021837603,
-0.0171... | from transformers import Wav2Vec2FeatureExtractor
w2v2_extractor = Wav2Vec2FeatureExtractor()
print(w2v2_extractor)
Wav2Vec2FeatureExtractor {
"do_normalize": true,
"feature_extractor_type": "Wav2Vec2FeatureExtractor",
"feature_size": 1,
"padding_side": "right",
"padding_value": 0.0,
"return_attention_mask"... |
[
0.02739988,
0.011240793,
-0.03050767,
-0.062269863,
0.028754193,
0.01692178,
0.002735355,
-0.00021940754,
0.015524698,
0.029794876,
0.048327573,
-0.020998972,
0.04673091,
-0.055826187,
0.040059138,
0.056624517,
-0.017834157,
-0.04644579,
-0.070310205,
-0.013813987,
-0.0106563... | With two basic classes - configuration and model - and an additional preprocessing class (tokenizer, image processor, feature extractor, or processor), you can create any of the models supported by 🤗 Transformers. Each of these base classes are configurable, allowing you to use the specific attributes you want. You ca... |
[
0.038499076,
0.03881747,
-0.019408735,
-0.0014767154,
-0.025630672,
-0.015866607,
0.040356368,
-0.013153629,
0.03377624,
0.056886297,
-0.012105584,
0.007548578,
0.009346174,
-0.060494754,
0.010036027,
0.044309754,
0.002877149,
-0.03504981,
-0.054498345,
0.012344379,
0.0315209... | If you have access to a machine with multiple GPUs, these approaches are still valid, plus you can leverage additional methods outlined in the multi-GPU section.
When training large models, there are two aspects that should be considered at the same time:
Data throughput/training time
Model performance |
[
0.0065195546,
0.008044819,
0.0046034628,
0.013357305,
-0.04728666,
-0.013322718,
0.025220472,
0.005509629,
0.01997716,
0.061093587,
0.038792215,
-0.004513538,
0.015577758,
-0.048780795,
-0.01790197,
0.04795072,
-0.017431594,
-0.06469058,
-0.054951027,
0.007788879,
0.016504677... | Note: when using mixed precision with a small model and a large batch size, there will be some memory savings but with a
large model and a small batch size, the memory use will be larger. |
[
0.027878562,
0.002272562,
-0.02540677,
0.020139018,
-0.016775763,
-0.01715396,
0.00836762,
-0.019666271,
-0.0072667957,
0.033038255,
0.038414065,
-0.030417887,
0.006064668,
-0.04127756,
-0.04049415,
0.0072127674,
-0.004659934,
-0.04897658,
-0.0438439,
0.0053656776,
0.01285871... | While gradient checkpointing may improve memory efficiency, it slows training by approximately 20%. |
[
0.06617356,
0.023923395,
-0.02923004,
-0.010337806,
-0.03291279,
-0.029128546,
0.023937894,
0.0047049345,
0.0058322335,
0.06379572,
0.04680286,
0.0074597495,
0.024517855,
-0.042569146,
0.04891972,
0.022763472,
0.016151916,
-0.023198444,
-0.07829475,
0.02920104,
-0.006901537,
... | Methods and tools for efficient training on a single GPU
This guide demonstrates practical techniques that you can use to increase the efficiency of your model's training by
optimizing memory utilization, speeding up the training, or both. If you'd like to understand how GPU is utilized during
training, please refer ... |
[
0.031666115,
0.022145776,
0.005082397,
0.035210613,
-0.040307656,
-0.005349699,
-0.0025540143,
0.017663892,
-0.0083486065,
0.03477121,
0.05337249,
-0.009447107,
0.05205429,
-0.04224102,
-0.009198113,
0.04060059,
0.022277595,
-0.045697633,
-0.058264483,
0.013914343,
-0.0147125... |
Maximizing the throughput (samples/second) leads to lower training cost. This is generally achieved by utilizing the GPU
as much as possible and thus filling GPU memory to its limit. If the desired batch size exceeds the limits of the GPU memory,
the memory optimization techniques, such as gradient accumulation, ca... |
[
-0.0042720824,
-0.029516205,
-0.033185642,
0.027427036,
-0.018440932,
0.016177665,
-0.00046453872,
0.010432452,
-0.0048948154,
0.07638858,
0.006565481,
-0.010954744,
0.019766752,
-0.05297918,
0.009883376,
0.0007227553,
0.025391435,
0.010814127,
-0.021213097,
-0.0104793245,
0.... | tf32 can't be accessed directly via tensor.to(dtype=torch.tf32) because it is an internal CUDA data type. You need torch>=1.7 to use tf32 data types. |
[
0.03556822,
0.029689666,
-0.04699874,
-0.026008146,
-0.018852938,
-0.025458887,
0.002924432,
-0.011400832,
0.0025700117,
0.04174367,
0.0065688384,
-0.011163314,
0.03429156,
-0.042337462,
0.008944011,
0.010636322,
-0.0030821583,
-0.061695125,
-0.08889086,
-0.0018286979,
0.0252... |
You can combine the above methods to get a cumulative effect. These techniques are available to you whether you are
training your model with [Trainer] or writing a pure PyTorch loop, in which case you can configure these optimizations
with 🤗 Accelerate.
If these methods do not result in sufficient gains, you can e... |
[
0.015415616,
-0.008359275,
-0.026336841,
0.030333482,
-0.04418265,
-0.017611573,
0.024682553,
0.013995565,
-0.026790673,
0.04875024,
0.025560936,
0.020568796,
0.02790329,
-0.059232272,
0.0051568383,
0.027259143,
-0.01774333,
-0.037301984,
-0.085847266,
-0.011001743,
0.0188705... |
Mixed precision training
Mixed precision training is a technique that aims to optimize the computational efficiency of training models by
utilizing lower-precision numerical formats for certain variables. Traditionally, most models use 32-bit floating point
precision (fp32 or float32) to represent and process varia... |
[
0.06866737,
-0.013349695,
-0.019395228,
-0.008617809,
-0.0308673,
-0.0012414323,
-0.008562787,
0.0010007113,
-0.015364873,
0.041569065,
0.03606687,
0.0005953544,
0.03342582,
-0.049794845,
-0.022242613,
0.039808363,
-0.0022868488,
-0.037800062,
-0.07037304,
-0.0029935366,
0.01... |
import bitsandbytes as bnb
from torch import nn
from transformers.trainer_pt_utils import get_parameter_names
training_args = TrainingArguments(per_device_train_batch_size=4, **default_args)
decay_parameters = get_parameter_names(model, [nn.LayerNorm])
decay_parameters = [name for name in decay_parameters if "bias" n... |
[
0.05024728,
0.009444237,
-0.025686637,
0.015960902,
-0.02789639,
-0.0073330067,
0.0018209362,
0.034990124,
-0.014736388,
0.028023064,
0.03228775,
0.003311113,
0.021436024,
-0.06862906,
0.0137722595,
0.008853093,
0.008487146,
-0.039888177,
-0.062323518,
0.005221776,
-0.0025440... |
Finally, pass the custom optimizer as an argument to the Trainer:
py
trainer = Trainer(model=model, args=training_args, train_dataset=ds, optimizers=(adam_bnb_optim, None))
Combined with other approaches (gradient accumulation, gradient checkpointing, and mixed precision training),
you can expect to get about a 3x m... |
[
0.04078708,
0.016049525,
-0.03489788,
-0.004861505,
-0.035918284,
0.00086506724,
0.0061916765,
-0.010029132,
-0.012820669,
0.043527596,
0.010546623,
0.003518578,
0.025641339,
-0.06565583,
0.024314811,
0.032390594,
0.033877473,
-0.01833815,
-0.071020246,
-0.0036953266,
0.01516... |
For additional information on tf32 vs other precisions, please refer to the following benchmarks:
RTX-3090 and
A100.
Flash Attention 2
You can speedup the training throughput by using Flash Attention 2 integration in transformers. Check out the appropriate section in the single GPU section to learn more about how to... |
[
0.023012547,
0.013192093,
0.0030532482,
-0.0063236654,
-0.022747528,
-0.021069068,
0.015061955,
-0.02285059,
-0.01282401,
0.036278255,
0.0051421192,
0.007906422,
0.038133394,
-0.031949602,
0.021407705,
0.0013195775,
0.024823515,
-0.040489126,
-0.038781222,
0.01437732,
0.01275... | DataLoader(pin_memory=True, ) - ensures the data gets preloaded into the pinned memory on CPU and typically leads to much faster transfers from CPU to GPU memory.
DataLoader(num_workers=4, ) - spawn several workers to preload data faster. During training, watch the GPU utilization stats; if it's far from 100%, experime... |
[
0.029522112,
0.04193957,
-0.013628919,
-0.010419993,
-0.04643928,
-0.03449775,
0.006962286,
-0.018518023,
-0.034411214,
0.05024672,
0.005967159,
0.014797111,
0.03328629,
-0.060803726,
0.033661265,
0.030949904,
0.023926323,
-0.025974266,
-0.066341825,
0.0258012,
0.01019645,
... |
When using [Trainer], the corresponding [TrainingArguments] are: dataloader_pin_memory (True by default), and dataloader_num_workers (defaults to 0).
DeepSpeed ZeRO
DeepSpeed is an open-source deep learning optimization library that is integrated with 🤗 Transformers and 🤗 Accelerate.
It provides a wide range of fea... |
[
0.009658049,
0.0076560387,
-0.021897445,
0.00872671,
-0.03807486,
0.015400078,
0.013654736,
0.016456082,
0.018714761,
0.067173675,
-0.005184693,
0.031122824,
0.021193441,
-0.030154819,
0.04215221,
0.058930963,
0.008484709,
-0.06259765,
-0.09069912,
0.034701508,
0.020504104,
... | For an in-depth guide on DeepSpeed integration with [Trainer], review the corresponding documentation, specifically the
section for a single GPU. Some adjustments are required to use DeepSpeed in a notebook; please take a look at the corresponding guide.
If you prefer to use 🤗 Accelerate, refer to 🤗 Accelerate DeepS... |
[
0.042722918,
-0.0023768942,
-0.019590935,
0.002393088,
0.004001675,
0.022800911,
-0.008183282,
0.004602646,
0.038750034,
0.0251904,
0.018266639,
-0.008953388,
0.0042967624,
-0.061263055,
-0.0025262374,
0.024700986,
-0.02608286,
-0.028011724,
-0.081242636,
0.04537151,
0.023822... |
Using torch.compile
PyTorch 2.0 introduced a new compile function that doesn't require any modification to existing PyTorch code but can
optimize your code by adding a single line of code: model = torch.compile(model).
If using [Trainer], you only need to pass the torch_compile option in the [TrainingArguments]:
py... |
[
0.008044286,
-0.010042732,
-0.020518338,
0.012199898,
-0.005144014,
0.01024474,
-0.021990119,
-0.00797214,
0.010417891,
0.04631777,
-0.009624284,
-0.008607024,
0.04940562,
-0.040921245,
-0.0030265271,
0.04057494,
-0.033389196,
-0.04559631,
-0.0856518,
0.009371773,
0.02067706,... |
from accelerate import Accelerator
from torch.utils.data.dataloader import DataLoader
dataloader = DataLoader(ds, batch_size=training_args.per_device_train_batch_size)
if training_args.gradient_checkpointing:
model.gradient_checkpointing_enable()
accelerator = Accelerator(fp16=training_args.fp16)
model, optimizer... |
[
0.041793715,
0.0021928588,
-0.032822147,
0.00268457,
-0.0043546623,
-0.03307059,
0.018371016,
0.000068958165,
-0.026597256,
0.07906024,
0.046293303,
-0.013850724,
0.016010802,
-0.06122752,
0.015555323,
0.015500113,
0.013443553,
-0.009578877,
-0.025962345,
-0.03500293,
0.00943... |
(source: GLAM)
You can find exhaustive details and comparison tables in the papers listed at the end of this section.
The main drawback of this approach is that it requires staggering amounts of GPU memory - almost an order of magnitude
larger than its dense equivalent. Various distillation and approaches are propos... |
[
0.036135208,
-0.011233447,
-0.020763122,
-0.0017609874,
-0.008620574,
-0.0115386,
0.032320794,
-0.026446598,
-0.024208808,
0.013337731,
0.032320794,
-0.021424288,
0.015346656,
-0.06774398,
-0.0039669895,
0.0074571776,
-0.008963871,
-0.03692352,
-0.052181173,
-0.024310526,
0.0... | GShard: Scaling Giant Models with Conditional Computation and Automatic Sharding
Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity
GLaM: Generalist Language Model (GLaM) |
[
0.036066562,
0.004822676,
-0.047168683,
-0.0035710037,
0.01712855,
0.00010165045,
-0.0037358487,
-0.016576512,
0.015702449,
0.035729203,
0.013126266,
-0.017005874,
0.049622193,
-0.029350085,
-0.0070346664,
0.011868843,
-0.027969986,
-0.032815665,
-0.0839713,
0.0012037521,
0.0... |
First we wrap the dataset in a DataLoader.
Then we can enable gradient checkpointing by calling the model's [~PreTrainedModel.gradient_checkpointing_enable] method.
When we initialize the Accelerator
we can specify if we want to use mixed precision training and it will take care of it for us in the [prepare] call.... |
[
0.022748401,
0.008433627,
-0.055826128,
-0.0015598477,
0.0014301714,
0.005716954,
-0.016523937,
-0.0357944,
-0.0014749517,
0.034749527,
-0.012710147,
0.0071088756,
0.033107582,
-0.032868754,
0.0005798118,
0.06466278,
-0.006642414,
-0.0056684418,
-0.006933486,
-0.015016333,
0.... |
And for Pytorch DeepSpeed has built one as well: DeepSpeed-MoE: Advancing Mixture-of-Experts Inference and Training to Power Next-Generation AI Scale, Mixture of Experts - blog posts: 1, 2 and specific deployment with large transformer-based natural language generation models: blog post, Megatron-Deepspeed branch.
U... |
[
0.022104545,
0.0017696965,
-0.03126914,
-0.03167261,
-0.0016760331,
0.0018129257,
-0.02184517,
0.007255305,
0.0261825,
0.029799346,
-0.003566411,
0.008184734,
0.053258408,
-0.05193271,
-0.0029053641,
0.027508197,
-0.027580246,
0.0005173998,
-0.03743651,
0.005468497,
0.0299434... | Installation
Install 🤗 Transformers for whichever deep learning library you're working with, setup your cache, and optionally configure 🤗 Transformers to run offline.
🤗 Transformers is tested on Python 3.6+, PyTorch 1.1.0+, TensorFlow 2.0+, and Flax. Follow the installation instructions below for the deep learning l... |
[
0.006325242,
0.02030774,
-0.048156276,
-0.025417428,
-0.022942651,
-0.01566389,
0.000055301516,
0.0133565245,
-0.019376058,
0.029333401,
-0.018808315,
0.002540287,
0.0607922,
-0.042507958,
0.0038541034,
0.032550614,
-0.016581016,
-0.019274157,
-0.032463267,
-0.007369744,
0.02... | python -m venv .env
Activate the virtual environment. On Linux and MacOs:
source .env/bin/activate
Activate Virtual environment on Windows
.env/Scripts/activate
Now you're ready to install 🤗 Transformers with the following command:
pip install transformers
For CPU-support only, you can conveniently install 🤗 Trans... |
[
0.018530687,
0.012707183,
-0.025802601,
-0.033358224,
0.004666269,
-0.028206661,
-0.014133195,
0.019740183,
0.0009593849,
0.02123339,
-0.019516204,
-0.009534121,
0.055995226,
-0.03942064,
0.013438854,
0.034821566,
-0.016828433,
-0.016574588,
-0.043004334,
0.029042857,
0.03992... | PyTorch installation instructions.
TensorFlow 2.0 installation instructions.
Flax installation instructions.
Install with pip
You should install 🤗 Transformers in a virtual environment. If you're unfamiliar with Python virtual environments, take a look at this guide. A virtual environment makes it easier to manage di... |
[
0.014152026,
-0.0043623107,
-0.018138215,
-0.025027925,
0.0062815873,
-0.040382136,
-0.0037260675,
0.003539764,
-0.0039791586,
0.041113287,
-0.020191068,
-0.016718091,
0.052418035,
-0.052952338,
0.015677605,
0.066197455,
0.00623589,
-0.017041486,
-0.020795675,
-0.008703531,
0... | pip install 'transformers[torch]'
🤗 Transformers and TensorFlow 2.0:
pip install 'transformers[tf-cpu]'
M1 / ARM Users
You will need to install the following before installing TensorFLow 2.0
brew install cmake
brew install pkg-config
🤗 Transformers and Flax:
pip install 'transformers[flax]'
Finally, check if 🤗 ... |
[
0.035794944,
-0.014377031,
-0.013491241,
-0.0150356935,
-0.018018605,
-0.050876062,
0.0022542183,
0.016807271,
0.0072945068,
0.019002816,
-0.017200954,
-0.008789748,
0.028314952,
-0.042366434,
0.00185391,
0.036854863,
0.016065327,
-0.014975127,
-0.030677054,
-0.007585984,
0.0... | 🤗 Transformers and Flax:
pip install 'transformers[flax]'
Finally, check if 🤗 Transformers has been properly installed by running the following command. It will download a pretrained model:
python -c "from transformers import pipeline; print(pipeline('sentiment-analysis')('we love you'))"
Then print out the label a... |
[
0.0366663,
0.032281347,
-0.028329117,
-0.016991701,
-0.0064367964,
-0.036435515,
0.02827142,
0.0062096156,
-0.0022050987,
0.013948196,
-0.03256983,
-0.016256066,
0.040705074,
-0.05189825,
-0.010623419,
0.018217757,
-0.0313005,
-0.008156882,
-0.022790227,
-0.010471965,
0.02421... |
pip install git+https://github.com/huggingface/transformers
This command installs the bleeding edge main version rather than the latest stable version. The main version is useful for staying up-to-date with the latest developments. For instance, if a bug has been fixed since the last official release but a new releas... |
[
0.022841204,
0.009346747,
-0.039806485,
-0.017152505,
-0.00497221,
-0.032864835,
0.0026265224,
-0.00749612,
0.0031503867,
0.019399181,
-0.03145346,
-0.027060922,
0.028673919,
-0.06538402,
0.0059695328,
0.017498149,
-0.016432418,
-0.017080497,
-0.0586728,
-0.0085762525,
0.0116... | python -c "from transformers import pipeline; print(pipeline('sentiment-analysis')('I love you'))"
Editable install
You will need an editable install if you'd like to:
Use the main version of the source code.
Contribute to 🤗 Transformers and need to test changes in the code.
Clone the repository and install 🤗 Trans... |
[
0.0548258,
0.01936968,
-0.037707075,
-0.02603652,
0.018853538,
-0.03762105,
0.009677671,
-0.0055341944,
0.00090862584,
0.00097135146,
-0.005075401,
-0.026796397,
0.04699764,
-0.062338542,
0.0057922653,
0.006674009,
0.02630893,
0.017204748,
-0.061134208,
0.014086388,
-0.003654... | You must keep the transformers folder if you want to keep using the library.
Now you can easily update your clone to the latest version of 🤗 Transformers with the following command:
cd ~/transformers/
git pull
Your Python environment will find the main version of 🤗 Transformers on the next run.
Install with conda
I... |
[
0.043946713,
0.01818827,
-0.026509792,
-0.057697784,
-0.018074859,
-0.03422173,
0.0095265135,
0.000590091,
-0.0029664033,
0.024354985,
-0.03368303,
-0.017578686,
0.041962024,
-0.027388725,
-0.020952659,
0.023802107,
0.0164304,
0.019251496,
-0.042926017,
0.015352997,
0.0268358... | git clone https://github.com/huggingface/transformers.git
cd transformers
pip install -e .
These commands will link the folder you cloned the repository to and your Python library paths. Python will now look inside the folder you cloned to in addition to the normal library paths. For example, if your Python packages ar... |
[
0.00094762817,
0.042885005,
0.0018000695,
-0.010464907,
-0.058084752,
-0.020100461,
0.003801822,
-0.008904218,
-0.007924075,
-0.0039431886,
0.0034474628,
-0.008383988,
0.047137316,
-0.034712125,
-0.0055830427,
0.0012336602,
0.0074076154,
0.012432731,
-0.06272912,
0.003958268,
... | conda install conda-forge::transformers
Cache setup
Pretrained models are downloaded and locally cached at: ~/.cache/huggingface/hub. This is the default directory given by the shell environment variable TRANSFORMERS_CACHE. On Windows, the default directory is given by C:\Users\username\.cache\huggingface\hub. You can ... |
[
0.024049565,
0.04064842,
0.0028127925,
0.007165298,
-0.049481116,
-0.0063841753,
-0.010282278,
0.0098241195,
-0.0014289287,
0.005096074,
0.0154421935,
0.008735054,
0.042691357,
-0.036472417,
-0.018461533,
-0.0056293407,
-0.0045365198,
-0.020910053,
-0.03599173,
0.00434875,
0.... | Shell environment variable (default): HUGGINGFACE_HUB_CACHE or TRANSFORMERS_CACHE.
Shell environment variable: HF_HOME.
Shell environment variable: XDG_CACHE_HOME + /huggingface.
🤗 Transformers will use the shell environment variables PYTORCH_TRANSFORMERS_CACHE or PYTORCH_PRETRAINED_BERT_CACHE if you are coming from ... |
[
0.026506897,
-0.006519901,
-0.046619136,
0.044497404,
0.008221705,
0.0054958714,
0.041020125,
-0.0243999,
0.025755452,
0.008855278,
0.02772984,
0.054693498,
0.029055921,
-0.07037073,
-0.031236589,
0.01813785,
0.010365537,
-0.02192455,
-0.06842581,
-0.0069435104,
0.013511298,
... | HF_DATASETS_OFFLINE=1 TRANSFORMERS_OFFLINE=1 \
python examples/pytorch/translation/run_translation.py --model_name_or_path google-t5/t5-small --dataset_name wmt16 --dataset_config ro-en
This script should run without hanging or waiting to timeout because it won't attempt to download the model from the Hub.
You can als... |
[
0.025504418,
0.018697396,
-0.028644996,
0.001374003,
-0.005678604,
-0.019340118,
0.040520765,
-0.017616453,
0.020800853,
0.0485548,
0.027812377,
0.0152500635,
0.01894572,
-0.04154328,
0.0067047696,
0.01062684,
-0.005737033,
-0.040754482,
-0.057173133,
0.01010828,
-0.005295161... | from transformers import T5Model
model = T5Model.from_pretrained("./path/to/local/directory", local_files_only=True)
Fetch models and tokenizers to use offline
Another option for using 🤗 Transformers offline is to download the files ahead of time, and then point to their local path when you need to use them offline. ... |
[
0.027362939,
0.008806955,
-0.016985862,
0.026121115,
-0.022295728,
-0.007044137,
-0.008742723,
-0.007479489,
0.037283253,
0.028205095,
0.014673501,
-0.017856566,
0.036398277,
-0.040937353,
0.018113494,
0.034228653,
0.02948974,
-0.029232811,
-0.047817342,
-0.028804597,
-0.0180... | Download a file through the user interface on the Model Hub by clicking on the ↓ icon.
Use the [PreTrainedModel.from_pretrained] and [PreTrainedModel.save_pretrained] workflow:
Download your files ahead of time with [PreTrainedModel.from_pretrained]:
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
toke... |
[
0.030145628,
0.003507077,
-0.0025296651,
0.041722246,
-0.023109714,
-0.015014786,
0.01621887,
0.0013047269,
-0.0035016367,
0.015943237,
0.0005911619,
-0.0043920064,
0.022848587,
-0.043898303,
-0.008631689,
-0.0024807039,
-0.009567393,
-0.041432105,
-0.05077464,
0.008486618,
-... | Now when you're offline, reload your files with [PreTrainedModel.from_pretrained] from the specified directory:
tokenizer = AutoTokenizer.from_pretrained("./your/path/bigscience_t0")
model = AutoModel.from_pretrained("./your/path/bigscience_t0")
Programmatically download files with the huggingface_hub library:
Insta... |
[
0.019785369,
0.038112715,
-0.028927172,
0.005671709,
0.0076546194,
-0.018166963,
0.010541504,
-0.03216398,
0.010986201,
0.006087245,
0.025223793,
0.04788147,
0.058962442,
-0.051643167,
-0.018443989,
-0.0055295513,
-0.032368105,
-0.047589865,
-0.061820164,
-0.0025661201,
0.001... | Offline mode
Run 🤗 Transformers in a firewalled or offline environment with locally cached files by setting the environment variable TRANSFORMERS_OFFLINE=1.
Add 🤗 Datasets to your offline training workflow with the environment variable HF_DATASETS_OFFLINE=1. |
[
0.04373433,
0.022219151,
-0.027102966,
-0.02204316,
-0.010977581,
0.035022665,
0.054000605,
0.010955581,
-0.03631328,
0.04795817,
0.017804654,
-0.048046164,
-0.029786862,
-0.046432894,
-0.013148164,
0.040478453,
-0.016338043,
-0.03971582,
-0.031678792,
-0.0022109156,
0.002671... |
Quantization
Quantization techniques focus on representing data with less information while also trying to not lose too much accuracy. This often means converting a data type to represent the same information with fewer bits. For example, if your model weights are stored as 32-bit floating points and they're quantized... |
[
0.025362242,
0.017985689,
-0.0030527967,
0.024109082,
-0.004450141,
-0.008295063,
-0.00819538,
-0.014496779,
0.0151803205,
0.04012959,
0.01105771,
-0.0037416783,
0.020406567,
-0.04517071,
0.00042142833,
0.03500303,
-0.00885756,
-0.047135893,
-0.05434156,
-0.015422408,
-0.0164... | from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
tokenizer = AutoTokenizer.from_pretrained("bigscience/T0_3B")
model = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0_3B")
Save your files to a specified directory with [PreTrainedModel.save_pretrained]:
tokenizer.save_pretrained("./your/path/bigscien... |
[
0.018446395,
0.03689279,
-0.01851538,
0.0011244437,
-0.013451934,
-0.015590447,
0.010982297,
-0.01628029,
0.016363071,
0.013134606,
0.023509841,
-0.023468452,
0.040535163,
-0.054552767,
-0.00085540506,
0.026117448,
0.007533083,
-0.06948096,
-0.014693651,
-0.009202503,
-0.0004... | Interested in adding a new quantization method to Transformers? Read the HfQuantizer guide to learn how! |
[
0.05657986,
0.020061765,
-0.009634434,
0.040751863,
-0.042188052,
-0.003031331,
0.024834102,
-0.011167865,
0.013681197,
0.014346929,
-0.010030882,
-0.010165526,
0.043743923,
-0.058345176,
-0.007771877,
-0.032044966,
0.004772336,
-0.03617401,
-0.015977602,
-0.0051912246,
0.001... | Programmatically download files with the huggingface_hub library:
Install the huggingface_hub library in your virtual environment:
python -m pip install huggingface_hub
Use the hf_hub_download function to download a file to a specific path. For example, the following command downloads the config.json file from the T... |
[
0.054702736,
0.008577813,
-0.025900811,
0.033083856,
0.01689062,
0.015314534,
0.018940927,
-0.02811849,
0.00034106395,
0.057045944,
0.025803177,
-0.048928402,
-0.014617152,
-0.0400019,
-0.02525922,
0.044297777,
-0.011883409,
-0.07593108,
-0.0176159,
-0.009867972,
0.019429095,... | AQLM
Try AQLM on Google Colab!
Additive Quantization of Language Models (AQLM) is a Large Language Models compression method. It quantizes multiple weights together and take advantage of interdependencies between them. AQLM represents groups of 8-16 weights as a sum of multiple vector codes.
Inference support for AQLM ... |
[
0.049478527,
0.02742735,
-0.003973052,
0.025270972,
-0.06250541,
0.017886117,
0.019569864,
-0.020411737,
0.04374788,
0.017103324,
0.028579388,
-0.006155276,
0.06350975,
-0.04362972,
-0.005294941,
-0.0025090044,
0.0029410184,
-0.02742735,
-0.030898232,
-0.01369152,
-0.00951907... | from huggingface_hub import hf_hub_download
hf_hub_download(repo_id="bigscience/T0_3B", filename="config.json", cache_dir="./your/path/bigscience_t0")
Once your file is downloaded and locally cached, specify it's local path to load and use it:
from transformers import AutoConfig
config = AutoConfig.from_pretrained(".... |
[
0.05149932,
0.023247669,
-0.028162293,
0.023858273,
-0.023411488,
0.028341008,
0.0035686884,
-0.024185915,
0.0001557927,
0.038423438,
0.0360108,
-0.021564782,
0.01895854,
-0.04974197,
-0.012286564,
0.055788446,
0.010745158,
-0.052601386,
-0.038274508,
-0.00041839475,
0.006217... |
pip install aqlm[gpu,cpu]
The library provides efficient kernels for both GPU and CPU inference and training.
The instructions on how to quantize models yourself, as well as all the relevant code can be found in the corresponding GitHub repository.
PEFT
Starting with version aqlm 1.0.2, AQLM supports Parameter-Effici... |
[
0.042293962,
0.009772242,
-0.03363748,
0.014534806,
-0.02752702,
0.010034332,
0.022644643,
0.005238071,
-0.011502041,
0.040317047,
0.015830282,
-0.025610013,
-0.0030683342,
-0.033038415,
0.0018683329,
0.051279932,
-0.0033472737,
-0.020862425,
-0.057360437,
-0.024846205,
0.013... |
pip install autoawq
AWQ-quantized models can be identified by checking the quantization_config attribute in the model's config.json file:
json
{
"_name_or_path": "/workspace/process/huggingfaceh4_zephyr-7b-alpha/source",
"architectures": [
"MistralForCausalLM"
],
"quantization_config": {
"qua... |
[
0.040961053,
0.0276799,
-0.0076607047,
0.005217596,
-0.034671348,
0.0014034879,
0.050161693,
0.00028528651,
-0.00012650072,
0.06637978,
0.0072188657,
-0.0061694984,
-0.0027972292,
-0.033605736,
-0.013268158,
-0.00037483196,
-0.013748983,
-0.07324127,
-0.04187072,
0.009707457,
... | Try AWQ quantization with this notebook! |
[
0.06843748,
0.037015602,
-0.043465506,
0.027012542,
-0.017052291,
0.023530735,
0.047717877,
-0.0032053313,
-0.011708288,
0.035845485,
0.020291513,
-0.049287543,
-0.016881054,
-0.07037816,
-0.01165121,
0.0667822,
0.0018675469,
-0.01946387,
-0.02375905,
-0.005087148,
0.01957802... |
Activation-aware Weight Quantization (AWQ) doesn't quantize all the weights in a model, and instead, it preserves a small percentage of weights that are important for LLM performance. This significantly reduces quantization loss such that you can run models in 4-bit precision without experiencing any performance degr... |
[
0.024694392,
0.04237286,
-0.061008047,
0.05878957,
-0.023474231,
-0.026177999,
-0.021602394,
-0.019162072,
0.017345697,
0.05784672,
0.010045529,
0.035356935,
0.010523888,
-0.050913986,
0.0027020324,
0.054075312,
0.02100618,
0.00032302202,
-0.03269477,
0.011972829,
0.005140621... | Fused modules
Fused modules offers improved accuracy and performance and it is supported out-of-the-box for AWQ modules for Llama and Mistral architectures, but you can also fuse AWQ modules for unsupported architectures.
Fused modules cannot be combined with other optimization techniques such as FlashAttention-2. |
[
0.022254538,
-0.0001531766,
0.0016586771,
0.032340486,
-0.050132215,
0.038290896,
-0.008642972,
-0.0012932847,
-0.026062801,
0.032876022,
0.0112685915,
-0.03210247,
0.0038157012,
-0.05224461,
0.0040685935,
0.083841294,
-0.015061978,
-0.03921321,
-0.04236693,
-0.023266109,
0.0... | from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "TheBloke/zephyr-7B-alpha-AWQ"
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="cuda:0")
Loading an AWQ-quantized model automatically sets other weights to fp16 by default for performance reasons. If you want to load these other ... |
[
0.02682601,
0.009950893,
-0.016161278,
0.057735167,
-0.009187087,
0.020615624,
-0.02251443,
-0.014647943,
0.012013883,
0.059105735,
0.0061675548,
0.016189832,
-0.007752274,
-0.035092246,
-0.0028303652,
0.084175706,
0.013113192,
-0.022000467,
-0.06641543,
0.0058177747,
0.00459... |
To enable fused modules for supported architectures, create an [AwqConfig] and set the parameters fuse_max_seq_len and do_fuse=True. The fuse_max_seq_len parameter is the total sequence length and it should include the context length and the expected generation length. You can set it to a larger value to be safe.
For... |
[
0.03672277,
0.0010747382,
-0.046335157,
0.036291078,
-0.02529727,
-0.00013085725,
-0.0122169405,
0.0053242263,
-0.014850274,
0.052868128,
0.029312024,
-0.0015262183,
0.025844082,
-0.032607287,
-0.008835337,
0.058537707,
0.0075330604,
-0.012698999,
-0.06515702,
0.0068207653,
-... |
For architectures that don't support fused modules yet, you need to create a custom fusing mapping to define which modules need to be fused with the modules_to_fuse parameter. For example, to fuse the AWQ modules of the TheBloke/Yi-34B-AWQ model.
thon
import torch
from transformers import AwqConfig, AutoModelForCausa... |
[
0.033544444,
-0.011003345,
0.0065019764,
0.015360834,
-0.044397056,
-0.044643708,
-0.009626213,
-0.024747249,
0.022732938,
0.050453693,
0.0151964,
0.009393266,
0.03686052,
-0.007920216,
0.009913973,
0.049713742,
0.032174163,
-0.009283644,
-0.062320314,
0.032037135,
0.00764615... | The parameter modules_to_fuse should include: |
[
0.038846035,
0.015327059,
0.00805307,
-0.019160751,
-0.015172785,
-0.043196544,
-0.00021116166,
-0.021382289,
-0.014278,
0.031996295,
0.040049367,
0.041993212,
0.008269052,
-0.051342174,
-0.0349892,
0.04020364,
0.0023738814,
-0.032921936,
-0.0017056849,
-0.00036639924,
0.0397... |
"attention": The names of the attention layers to fuse in the following order: query, key, value and output projection layer. If you don't want to fuse these layers, pass an empty list.
"layernorm": The names of all the LayerNorm layers you want to replace with a custom fused LayerNorm. If you don't want to fuse thes... |
[
0.014856896,
0.030792115,
-0.026478823,
0.006492404,
-0.041725114,
-0.005503941,
-0.017507775,
0.003077714,
-0.011861554,
0.048883982,
0.013636295,
-0.04370204,
0.0021248208,
-0.038669866,
-0.00052371685,
0.072726905,
-0.0035588408,
-0.05316732,
-0.013501504,
-0.019739304,
0.... | from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "TheBloke/zephyr-7B-alpha-AWQ"
model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float32)
AWQ quantization can also be combined with FlashAttention-2 to further accelerate inference:
from transformers import AutoModelForCau... |
[
0.028923545,
0.034593046,
-0.05454241,
0.00042990234,
-0.0456895,
0.023329841,
0.004149801,
0.014711898,
0.016735638,
0.0523595,
-0.00016153906,
-0.005373898,
-0.0025808353,
-0.067852095,
-0.011998421,
0.038322184,
-0.01969166,
-0.027619865,
-0.07221791,
0.0026831592,
0.00533... |
pip install git+https://github.com/casper-hansen/AutoAWQ.git
Get started by passing an AwqConfig() with version="exllama".
thon
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, AwqConfig
quantization_config = AwqConfig(version="exllama")
model = AutoModelForCausalLM.from_pretrained(
"The... |
[
0.03008276,
0.016444864,
-0.0046392945,
0.037171062,
-0.018060997,
0.048483994,
-0.0020751008,
-0.00090996095,
0.026978083,
0.07031597,
0.038106717,
0.02051355,
-0.007095392,
-0.03274796,
-0.0062731486,
0.061356355,
0.03291808,
-0.031358656,
-0.0032978333,
0.0023710374,
0.028... | Exllama-v2 support
Recent versions of autoawq supports exllama-v2 kernels for faster prefill and decoding. To get started, first install the latest version of autoawq by running: |
[
0.04560051,
0.0054009864,
-0.009338252,
0.025558803,
-0.04686719,
-0.018324649,
-0.002088264,
0.019549107,
0.006597296,
0.050470192,
0.0403086,
-0.021547649,
-0.014426087,
-0.052440587,
-0.00023376419,
0.0466983,
0.0118716145,
-0.044756055,
-0.027247712,
-0.004567088,
0.01444... |
The AutoGPTQ library implements the GPTQ algorithm, a post-training quantization technique where each row of the weight matrix is quantized independently to find a version of the weights that minimizes the error. These weights are quantized to int4, but they're restored to fp16 on the fly during inference. This can s... |
[
0.048175313,
0.0183688,
-0.04806122,
0.013662508,
-0.013120571,
0.00241554,
0.052482285,
-0.00020723727,
0.00029102352,
0.016785774,
-0.031546414,
-0.038791254,
0.00976912,
-0.03091891,
0.021748772,
0.05539163,
-0.041529458,
-0.0568463,
-0.029050656,
0.017028218,
0.022148093,... | pip install auto-gptq
pip install git+https://github.com/huggingface/optimum.git
pip install git+https://github.com/huggingface/transformers.git
pip install --upgrade accelerate
To quantize a model (currently only supported for text models), you need to create a [GPTQConfig] class and set the number of bits to quantize... |
[
0.037737787,
-0.006193684,
-0.01310528,
0.052068934,
-0.030152302,
0.012678596,
0.026549196,
0.018760528,
0.01957326,
0.048547104,
0.008709762,
-0.022444908,
0.023921369,
-0.031859037,
-0.019248167,
0.0509582,
0.004283767,
-0.064639166,
-0.030965032,
-0.0029122843,
-0.0051506... | Note this feature is supported on AMD GPUs.
AutoGPTQ
Try GPTQ quantization with PEFT in this notebook and learn more about it's details in this blog post! |
[
0.02468073,
-0.008705826,
0.00222091,
0.020683447,
-0.0244389,
-0.0028681569,
0.04571981,
0.008968991,
0.016529689,
0.0452646,
0.0054162466,
-0.015605049,
0.017994884,
-0.039802123,
-0.024552703,
0.04938991,
-0.024154397,
-0.03943227,
-0.055848155,
-0.0048828013,
0.00418221,
... |
You could also pass your own dataset as a list of strings, but it is highly recommended to use the same dataset from the GPTQ paper.
py
dataset = ["auto-gptq is an easy-to-use model quantization library with user-friendly apis, based on GPTQ algorithm."]
gptq_config = GPTQConfig(bits=4, dataset=dataset, tokenizer=tok... |
[
0.047761265,
0.027933702,
-0.0077530853,
0.016155792,
0.021013826,
-0.008099079,
0.03513602,
0.007131709,
0.009334771,
0.03394976,
0.032000896,
-0.011629628,
-0.003595864,
-0.064340726,
-0.011933255,
0.04663149,
-0.005712428,
-0.040022302,
-0.0032728189,
-0.005701836,
0.05171... | Depending on your hardware, it can take some time to quantize a model from scratch. It can take ~5 minutes to quantize the facebook/opt-350m model on a free-tier Google Colab GPU, but it'll take ~4 hours to quantize a 175B parameter model on a NVIDIA A100. Before you quantize a model, it is a good idea to check the Hub... |
[
0.036019232,
-0.0025725486,
-0.038320143,
0.033775132,
-0.018620351,
-0.025395263,
0.016844956,
-0.0036857217,
0.008450884,
0.034144413,
0.0028335317,
0.004182833,
0.008358563,
-0.035223853,
-0.008770456,
0.049398612,
0.008891182,
-0.05513669,
-0.055420756,
0.00008177917,
0.0... |
Once your model is quantized, you can push the model and tokenizer to the Hub where it can be easily shared and accessed. Use the [~PreTrainedModel.push_to_hub] method to save the [GPTQConfig]:
py
quantized_model.push_to_hub("opt-125m-gptq")
tokenizer.push_to_hub("opt-125m-gptq")
You could also save your quantized mo... |
[
0.027038682,
-0.00056469336,
-0.019091353,
0.044990472,
-0.03800511,
-0.020275312,
0.011713803,
-0.020497305,
-0.027571464,
0.04303694,
0.016412644,
0.0053463187,
0.010700037,
-0.02264323,
0.0034889816,
0.059582777,
-0.013452743,
-0.032973282,
-0.06257228,
-0.017167417,
0.006... | quantized_model.save_pretrained("opt-125m-gptq")
tokenizer.save_pretrained("opt-125m-gptq")
if quantized with device_map set
quantized_model.to("cpu")
quantized_model.save_pretrained("opt-125m-gptq")
Reload a quantized model with the [~PreTrainedModel.from_pretrained] method, and set device_map="auto" to automatically... |
[
0.02021915,
0.008656279,
-0.018060371,
0.011407664,
-0.039055552,
0.0011093725,
0.020007506,
-0.001964771,
0.0013756923,
0.040156107,
0.010173068,
-0.031238798,
0.008324702,
-0.045828193,
0.0011816844,
0.057539213,
-0.04340133,
-0.037390612,
-0.029686736,
-0.007178292,
0.0100... | from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig
model_id = "facebook/opt-125m"
tokenizer = AutoTokenizer.from_pretrained(model_id)
gptq_config = GPTQConfig(bits=4, dataset="c4", tokenizer=tokenizer) |
[
0.020389987,
-0.008845982,
-0.02276366,
0.01129337,
-0.048358034,
0.047856763,
-0.008890212,
-0.010976389,
-0.008764894,
0.054078434,
0.047561895,
-0.023633515,
0.024857208,
-0.054019462,
-0.015200346,
0.087870084,
0.0013960064,
-0.0321404,
-0.034617275,
0.008646947,
0.014971... | import torch
from transformers import AutoModelForCausalLM, GPTQConfig
gptq_config = GPTQConfig(bits=4, exllama_config={"version":2})
model = AutoModelForCausalLM.from_pretrained("{your_username}/opt-125m-gptq", device_map="auto", quantization_config=gptq_config)
Only 4-bit models are supported, and we recommend deact... |
[
0.020176534,
0.02408786,
-0.011106688,
0.0075274557,
-0.010781974,
0.020117495,
0.008804171,
-0.005992445,
-0.01097385,
0.07515648,
0.029667033,
0.00071492384,
-0.019689463,
-0.0481462,
-0.017505025,
0.06978394,
-0.0032655874,
-0.04029403,
0.00470466,
0.021298273,
0.02613946,... | from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("{your_username}/opt-125m-gptq", device_map="auto")
ExLlama
ExLlama is a Python/C++/CUDA implementation of the Llama model that is designed for faster inference with 4-bit GPTQ weights (check out these benchmarks). The ExLlama k... |
[
0.029921522,
-0.00011934582,
-0.0124880895,
0.00022183877,
-0.008856125,
0.019076988,
0.0121359,
-0.0033861652,
-0.001221661,
0.05740706,
0.014630582,
-0.025768608,
-0.00096944114,
-0.056086343,
-0.025196299,
0.07131859,
0.017932368,
-0.043935772,
-0.035483196,
0.031521052,
0... |
The ExLlama kernels are only supported when the entire model is on the GPU. If you're doing inference on a CPU with AutoGPTQ (version > 0.4.2), then you'll need to disable the ExLlama kernel. This overwrites the attributes related to the ExLlama kernels in the quantization config of the config.json file.
py
import to... |
[
0.04652529,
-0.0105169,
-0.00022959591,
-0.01529194,
-0.029949177,
0.012155321,
0.021447094,
-0.013026195,
-0.013771603,
0.047558527,
0.047558527,
-0.031174304,
0.015675716,
-0.0420676,
0.013299265,
0.047351878,
0.0030775769,
-0.03185329,
-0.019734869,
-0.013845406,
0.0017574... | Quantizing a model in 8-bit halves the memory-usage, and for large models, set device_map="auto" to efficiently use the GPUs available:
from transformers import AutoModelForCausalLM
model_8bit = AutoModelForCausalLM.from_pretrained("bigscience/bloom-1b7", device_map="auto", load_in_8bit=True)
By default, all the othe... |
[
0.050365325,
-0.03608561,
-0.04037811,
-0.021476805,
-0.011060339,
-0.000746716,
0.019645339,
-0.02708567,
-0.02562622,
0.025568986,
-0.00492922,
-0.05168169,
0.033138093,
-0.036801025,
0.027844012,
0.051710308,
0.004589397,
-0.036915492,
-0.020174745,
0.030133344,
0.00933618... | pip install transformers accelerate bitsandbytes>0.37.0
pip install bitsandbytes>=0.39.0
pip install --upgrade accelerate
pip install --upgrade transformers
Now you can quantize a model with the load_in_8bit or load_in_4bit parameters in the [~PreTrainedModel.from_pretrained] method. This works for any model in any m... |
[
0.029916836,
-0.01955104,
-0.026461571,
-0.017031576,
-0.0072848503,
0.011978252,
0.016700447,
-0.009084468,
-0.029974423,
0.049295112,
-0.000045918358,
-0.014080205,
-0.0069969115,
-0.06357688,
0.0086093685,
0.040628158,
0.014332151,
-0.019435866,
-0.028074028,
0.01541912,
0... | Once a model is quantized to 8-bit, you can't push the quantized weights to the Hub unless you're using the latest version of Transformers and bitsandbytes. If you have the latest versions, then you can push the 8-bit model to the Hub with the [~PreTrainedModel.push_to_hub] method. The quantization config.json file is ... |
[
0.03231797,
-0.017357029,
0.0014756396,
-0.016597293,
-0.022046933,
0.025524184,
0.018964162,
0.0034480293,
-0.0067280405,
0.04663606,
0.04283738,
-0.012155765,
0.030272529,
-0.05917169,
-0.007699625,
0.050084088,
-0.01946091,
-0.01789761,
-0.02334725,
-0.024559904,
0.0207027... | By default, all the other modules such as torch.nn.LayerNorm are converted to torch.float16. You can change the data type of these modules with the torch_dtype parameter if you want:
import torch
from transformers import AutoModelForCausalLM
model_8bit = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", load_i... |
[
0.03827596,
-0.00074097776,
-0.0010705035,
0.006142651,
-0.037372954,
0.0020172072,
0.021206165,
-0.004806342,
-0.019254498,
0.029551722,
0.036120392,
-0.046723474,
-0.002574306,
-0.03212967,
0.01249649,
0.043577503,
0.0044859196,
-0.06280287,
-0.04002372,
0.017768903,
-0.002... | from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("bigscience/bloom-560m", device_map="auto", load_in_8bit=True)
tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom-560m")
model.push_to_hub("bloom-560m-8bit")
Quantizing a model in 4-bit reduces your memor... |
[
0.037632063,
-0.02116439,
-0.001830552,
-0.009655979,
-0.021674901,
0.025773589,
0.018393036,
0.006640309,
-0.007427957,
0.042241264,
0.04766728,
-0.0122304205,
0.03474402,
-0.060561366,
-0.010071682,
0.053589225,
-0.017459527,
-0.020595532,
-0.030805783,
-0.015898818,
0.0183... | By default, all the other modules such as torch.nn.LayerNorm are converted to torch.float16. You can change the data type of these modules with the torch_dtype parameter if you want:
import torch
from transformers import AutoModelForCausalLM
model_4bit = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", load_i... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.