vector listlengths 1.02k 1.02k | text stringlengths 2 11.8k |
|---|---|
[
0.017450048,
0.027976139,
-0.013819876,
-0.013910981,
0.009054402,
-0.01927214,
-0.04538414,
-0.01614655,
0.011808566,
0.060213175,
-0.023126569,
0.004418576,
-0.00076212554,
-0.06727729,
-0.0045166886,
0.0008659323,
-0.018347077,
-0.08151765,
-0.044459075,
-0.037002508,
-0.0... | Text, use a Tokenizer to convert text into a sequence of tokens, create a numerical representation of the tokens, and assemble them into tensors.
Speech and audio, use a Feature extractor to extract sequential features from audio waveforms and convert them into tensors.
Image inputs use a ImageProcessor to convert imag... |
[
0.02303682,
-0.00828121,
-0.0087192245,
-0.006159578,
-0.034712642,
0.010395998,
0.008397558,
0.025897603,
0.003938708,
0.06800174,
-0.015864335,
-0.0070492947,
0.01496093,
-0.023091573,
-0.008869792,
0.015919087,
0.014317596,
-0.0591867,
-0.06422386,
-0.028744696,
0.01587802... | AutoProcessor always works and automatically chooses the correct class for the model you're using, whether you're using a tokenizer, image processor, feature extractor or processor.
Before you begin, install 🤗 Datasets so you can load some datasets to experiment with:
pip install datasets
Natural Language Processing |
[
0.0074918536,
-0.023553181,
-0.004722405,
0.010636446,
-0.026936837,
0.0021699527,
0.014696832,
-0.009275628,
0.00054616603,
0.061435405,
0.011666254,
0.0053329347,
0.0037992562,
-0.050401747,
-0.007826541,
0.032836165,
0.00027354277,
-0.029702606,
-0.072204255,
0.005939786,
... | If you plan on using a pretrained model, it's important to use the associated pretrained tokenizer. This ensures the text is split the same way as the pretraining corpus, and uses the same corresponding tokens-to-index (usually referred to as the vocab) during pretraining.
Get started by loading a pretrained tokenizer... |
[
0.035197075,
-0.010226371,
-0.024511736,
0.012829578,
-0.021514105,
-0.00440322,
0.021327648,
0.0032737295,
0.00053471513,
0.029173125,
0.024884647,
-0.029603407,
0.012341924,
-0.04015966,
0.01929098,
0.030291859,
0.0061781337,
-0.03964332,
-0.042913467,
-0.0046362896,
-0.042... | Get started by loading a pretrained tokenizer with the [AutoTokenizer.from_pretrained] method. This downloads the vocab a model was pretrained with:
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")
Then pass your text to the tokenizer: |
[
0.013469498,
-0.019460663,
-0.004574814,
-0.01667045,
0.015084138,
0.0032629187,
-0.0076766224,
-0.024941942,
-0.0063842023,
0.03631524,
-0.033057634,
-0.016996212,
0.009220445,
-0.031244703,
-0.0007896157,
0.00016310166,
-0.035295468,
-0.045946427,
-0.04056429,
-0.021046976,
... | Before you begin, install 🤗 Datasets so you can load some datasets to experiment with:
pip install datasets
Natural Language Processing
The main tool for preprocessing textual data is a tokenizer. A tokenizer splits text into tokens according to a set of rules. The tokens are converted into numbers and then tensors,... |
[
0.009508875,
0.00023022221,
0.012187825,
0.008811232,
-0.010129777,
-0.052797627,
0.027794098,
-0.0011929696,
-0.027417373,
0.056732334,
-0.0047509493,
0.026691822,
-0.0019534004,
-0.017678276,
-0.022129238,
-0.047969937,
-0.025101198,
-0.050007053,
-0.026147662,
-0.011818074,
... | Then pass your text to the tokenizer:
encoded_input = tokenizer("Do not meddle in the affairs of wizards, for they are subtle and quick to anger.")
print(encoded_input)
{'input_ids': [101, 2079, 2025, 19960, 10362, 1999, 1996, 3821, 1997, 16657, 1010, 2005, 2027, 2024, 11259, 1998, 4248, 2000, 4963, 1012, 102],
'toke... |
[
0.030563097,
-0.0011147205,
-0.00519615,
-0.022153307,
0.025864339,
-0.015055782,
0.0047587277,
0.0020266043,
-0.013461309,
0.033074744,
0.013863455,
0.011528186,
0.032312784,
-0.048765495,
0.001670317,
0.028277215,
-0.006197987,
-0.019063132,
-0.05000721,
-0.01828706,
0.0030... | Preprocess
[[open-in-colab]]
Before you can train a model on a dataset, it needs to be preprocessed into the expected model input format. Whether your data is text, images, or audio, they need to be converted and assembled into batches of tensors. 🤗 Transformers provides a set of preprocessing classes to help prepare ... |
[
0.033140212,
0.008717748,
-0.007880731,
-0.004493648,
-0.02241504,
-0.054590553,
0.0045965016,
-0.0030182276,
-0.007476409,
0.072919816,
-0.022117117,
0.028855817,
0.018527875,
-0.036999002,
-0.051668085,
-0.00897311,
-0.033111837,
-0.07064994,
-0.022840641,
-0.0015552207,
0.... |
batch_sentences = [
"But what about second breakfast?",
"Don't think he knows about second breakfast, Pip.",
"What about elevensies?",
]
encoded_inputs = tokenizer(batch_sentences)
print(encoded_inputs)
{'input_ids': [[101, 1252, 1184, 1164, 1248, 6462, 136, 102],
[101, 1790, 112, 189, ... |
[
0.003307359,
0.00770276,
0.0037937355,
-0.0025543766,
-0.02315872,
-0.030839862,
-0.00025489723,
0.0029074496,
-0.03810308,
0.06646423,
-0.01766807,
0.04744151,
-0.035768475,
-0.01652959,
-0.045251016,
-0.01477143,
-0.010159861,
-0.031070441,
-0.035595544,
-0.0027056935,
0.02... | The tokenizer returns a dictionary with three important items:
input_ids are the indices corresponding to each token in the sentence.
attention_mask indicates whether a token should be attended to or not.
token_type_ids identifies which sequence a token belongs to when there is more than one sequence.
Return your inp... |
[
0.025511455,
-0.019959738,
0.0076372805,
0.016229222,
-0.023411203,
-0.027009536,
0.0061832597,
0.032693435,
-0.037863288,
0.06233196,
0.009157393,
0.02382244,
-0.040183846,
-0.032340948,
-0.05161039,
-0.033985898,
0.007046126,
-0.046411168,
-0.051698513,
-0.01382054,
0.03307... | Return your input by decoding the input_ids:
tokenizer.decode(encoded_input["input_ids"])
'[CLS] Do not meddle in the affairs of wizards, for they are subtle and quick to anger. [SEP]'
As you can see, the tokenizer added two special tokens - CLS and SEP (classifier and separator) - to the sentence. Not all models nee... |
[
0.029753411,
0.0062574334,
-0.0029865024,
-0.0020468072,
-0.027449178,
-0.050088268,
0.0074023493,
-0.0012682284,
-0.0077839876,
0.07223771,
-0.021458171,
0.022466274,
0.017555377,
-0.024050433,
-0.057749845,
-0.0091377245,
-0.035110753,
-0.08036013,
-0.02085331,
0.0072511337,
... |
batch_sentences = [
"But what about second breakfast?",
"Don't think he knows about second breakfast, Pip.",
"What about elevensies?",
]
encoded_input = tokenizer(batch_sentences, padding=True, truncation=True)
print(encoded_input)
{'input_ids': [[101, 1252, 1184, 1164, 1248, 6462, 136, 102, 0, 0, 0, ... |
[
0.03756829,
-0.013209988,
0.0003731145,
-0.0015592715,
-0.025656395,
0.0050674155,
-0.03282019,
0.016160196,
-0.014577497,
0.045120824,
0.016535046,
-0.0018482184,
-0.03368096,
-0.032209326,
-0.021088779,
0.026836477,
-0.008371648,
-0.043704722,
-0.021727411,
0.020241896,
-0.... | Check out the Padding and truncation concept guide to learn more different padding and truncation arguments.
Build tensors
Finally, you want the tokenizer to return the actual tensors that get fed to the model.
Set the return_tensors parameter to either pt for PyTorch, or tf for TensorFlow: |
[
0.041654207,
0.017644791,
0.040205117,
0.03486338,
-0.0077142683,
-0.003881996,
0.0052103275,
-0.024904443,
-0.046001475,
0.061543666,
0.008509846,
0.02920909,
-0.01440565,
-0.04242137,
-0.06290752,
0.0070181373,
-0.0052564996,
-0.044950176,
-0.03293126,
0.026509807,
0.007728... | Pad
Sentences aren't always the same length which can be an issue because tensors, the model inputs, need to have a uniform shape. Padding is a strategy for ensuring tensors are rectangular by adding a special padding token to shorter sentences.
Set the padding parameter to True to pad the shorter sequences in the batc... |
[
0.032342672,
0.006755882,
-0.006727361,
-0.0035009373,
-0.024242742,
-0.051423136,
0.0057719117,
-0.0025989646,
-0.0051373225,
0.07295639,
-0.02250297,
0.024855942,
0.020506509,
-0.029832834,
-0.054389305,
-0.011714948,
-0.03530884,
-0.07712044,
-0.019394195,
0.0037041483,
0.... |
batch_sentences = [
"But what about second breakfast?",
"Don't think he knows about second breakfast, Pip.",
"What about elevensies?",
]
encoded_input = tokenizer(batch_sentences, padding=True)
print(encoded_input)
{'input_ids': [[101, 1252, 1184, 1164, 1248, 6462, 136, 102, 0, 0, 0, 0, 0, 0, 0],
... |
[
0.045902483,
-0.018098537,
0.06036491,
0.024659941,
-0.020818785,
-0.021980701,
0.0016950291,
-0.0052593746,
-0.029280262,
0.06933216,
0.04161023,
0.0005805304,
-0.0055532707,
-0.011386768,
-0.03127602,
0.029170904,
0.003311458,
-0.0606383,
-0.026190935,
0.049374558,
0.012610... | The first and third sentences are now padded with 0's because they are shorter.
Truncation
On the other end of the spectrum, sometimes a sequence may be too long for a model to handle. In this case, you'll need to truncate the sequence to a shorter length.
Set the truncation parameter to True to truncate a sequence to ... |
[
0.03646979,
0.016353406,
0.0026931483,
0.031037519,
-0.03491367,
-0.010503809,
0.0121943215,
0.010404783,
-0.041732308,
0.07044979,
-0.013361411,
0.0072324206,
0.017442688,
-0.018475387,
-0.03324438,
0.02215349,
-0.025888177,
-0.03177314,
-0.012081149,
0.022931548,
-0.0121023... | Different pipelines support tokenizer arguments in their __call__() differently. text-2-text-generation pipelines support (i.e. pass on)
only truncation. text-generation pipelines support max_length, truncation, padding and add_special_tokens.
In fill-mask pipelines, tokenizer arguments can be passed in the tokenizer_... |
[
0.02768331,
0.023942322,
-0.009948256,
0.009470241,
-0.021628452,
-0.04810633,
-0.0035019803,
-0.006120672,
-0.021531463,
0.07204866,
-0.02416401,
0.026962824,
0.022390505,
-0.044919565,
-0.052540097,
-0.017360955,
-0.02089411,
-0.08191378,
-0.01694529,
0.002151068,
0.0133290... |
batch_sentences = [
"But what about second breakfast?",
"Don't think he knows about second breakfast, Pip.",
"What about elevensies?",
]
encoded_input = tokenizer(batch_sentences, padding=True, truncation=True, return_tensors="pt")
print(encoded_input)
{'input_ids': tensor([[101, 1252, 1184, 1164, 124... |
[
0.009285121,
0.048445396,
-0.0024378067,
0.0093073165,
-0.029327666,
-0.0598095,
-0.030718584,
-0.04566356,
0.024326278,
0.07256452,
0.0543642,
0.005737539,
0.044450205,
-0.040928517,
-0.0054933885,
0.033382047,
-0.035009716,
-0.03577916,
-0.044509392,
-0.013502268,
0.0056672... | This returns three items:
array is the speech signal loaded - and potentially resampled - as a 1D array.
path points to the location of the audio file.
sampling_rate refers to how many data points in the speech signal are measured per second. |
[
-0.002371704,
0.032904346,
-0.033043653,
-0.019809473,
-0.0054329783,
-0.013443138,
-0.019112939,
-0.021578675,
0.0079196105,
0.036080547,
0.00996046,
-0.00017805192,
0.038504492,
-0.059902065,
-0.0052692923,
0.033684466,
-0.004231454,
-0.019767681,
-0.046584304,
-0.048172407,
... | Audio
For audio tasks, you'll need a feature extractor to prepare your dataset for the model. The feature extractor is designed to extract features from raw audio data, and convert them into tensors.
Load the MInDS-14 dataset (see the 🤗 Datasets tutorial for more details on how to load a dataset) to see how you can us... |
[
-0.0028434377,
0.025320303,
0.009714786,
0.005736082,
-0.016505295,
-0.018332968,
-0.023408275,
-0.042767555,
0.006512843,
0.04496076,
0.03500697,
0.009532019,
0.032504465,
-0.033263654,
-0.024195582,
0.015942933,
-0.0172926,
-0.021650897,
-0.03759383,
-0.0067237285,
-0.01976... | from datasets import load_dataset, Audio
dataset = load_dataset("PolyAI/minds14", name="en-US", split="train")
Access the first element of the audio column to take a look at the input. Calling the audio column automatically loads and resamples the audio file: |
[
0.0006378204,
0.031709842,
-0.006929133,
0.023649272,
-0.019478481,
-0.0135107,
-0.014974914,
-0.028367294,
0.0138286855,
0.055580962,
0.044163056,
-0.0195968,
0.020055292,
-0.013917426,
-0.017333925,
-0.0025660717,
-0.020144032,
-0.032419764,
-0.036265172,
0.0005199623,
-0.0... | Access the first element of the audio column to take a look at the input. Calling the audio column automatically loads and resamples the audio file:
dataset[0]["audio"]
{'array': array([ 0. , 0.00024414, -0.00024414, , -0.00024414,
0. , 0. ], dtype=float32),
'path': '/root/.cache/huggi... |
[
-0.0046843844,
0.06405948,
0.013201446,
0.00066844973,
-0.021976814,
-0.039094713,
-0.037363376,
-0.012628988,
-0.00016918499,
0.057162054,
0.024392309,
-0.026765915,
0.05970321,
-0.06428288,
0.0063982685,
0.022633046,
-0.023736075,
-0.05213559,
-0.05679903,
-0.05573789,
-0.0... | For this tutorial, you'll use the Wav2Vec2 model. Take a look at the model card, and you'll learn Wav2Vec2 is pretrained on 16kHz sampled speech audio. It is important your audio data's sampling rate matches the sampling rate of the dataset used to pretrain the model. If your data's sampling rate isn't the same, then y... |
[
0.007432604,
0.029239906,
-0.002450852,
0.014892459,
-0.020683214,
-0.034499273,
-0.017304137,
-0.015246717,
0.009312896,
0.038941123,
0.04245645,
-0.032727983,
0.047198057,
-0.040794164,
0.013495865,
0.0004394161,
-0.02560195,
-0.0624039,
-0.041148424,
-0.027345989,
-0.00267... | Use 🤗 Datasets' [~datasets.Dataset.cast_column] method to upsample the sampling rate to 16kHz:
dataset = dataset.cast_column("audio", Audio(sampling_rate=16_000))
Call the audio column again to resample the audio file: |
[
0.008681731,
0.038638245,
-0.0033612899,
0.028608505,
-0.00813694,
-0.044058215,
-0.032268383,
-0.027602738,
0.0035830475,
0.059954934,
0.051433846,
-0.034419607,
0.041962866,
-0.027812272,
-0.0050672535,
0.007501351,
-0.029334892,
-0.04453316,
-0.039029375,
0.0013846768,
-0.... | dataset = dataset.cast_column("audio", Audio(sampling_rate=16_000))
Call the audio column again to resample the audio file:
dataset[0]["audio"]
{'array': array([ 2.3443763e-05, 2.1729663e-04, 2.2145823e-04, ,
3.8356509e-05, -7.3497440e-06, -2.1754686e-05], dtype=float32),
'path': '/root/.cache/huggingface... |
[
-0.009352801,
0.06317553,
0.025720203,
-0.008308699,
-0.034528896,
-0.033764202,
-0.0244114,
0.006709459,
-0.026499605,
0.041440558,
0.009698384,
-0.0023308476,
0.0007757237,
-0.046087548,
-0.01651446,
0.038470015,
-0.02122027,
-0.041969962,
-0.025940789,
-0.035881817,
-0.003... | Next, load a feature extractor to normalize and pad the input. When padding textual data, a 0 is added for shorter sequences. The same idea applies to audio data. The feature extractor adds a 0 - interpreted as silence - to array.
Load the feature extractor with [AutoFeatureExtractor.from_pretrained]:
from transformer... |
[
0.0008575161,
0.06924586,
-0.0059180562,
-0.004912235,
-0.03527459,
-0.00038183152,
-0.038872883,
0.027483014,
0.023544727,
0.026434693,
0.020640593,
-0.03929788,
0.053719375,
-0.042981166,
0.0063572177,
0.055306025,
-0.017963124,
-0.042357843,
-0.035217926,
-0.062219277,
-0.... | from transformers import AutoFeatureExtractor
feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
Pass the audio array to the feature extractor. We also recommend adding the sampling_rate argument in the feature extractor in order to better debug any silent errors that may occur. |
[
0.018265022,
0.07965656,
-0.013199874,
0.005498215,
-0.035116516,
-0.024431894,
-0.013788844,
0.00068770995,
0.01872234,
0.046840496,
0.033702984,
-0.009659121,
0.034007866,
-0.04102008,
-0.022380888,
0.02384985,
-0.0050755423,
-0.047089946,
-0.05188486,
-0.059589982,
0.01250... | Pass the audio array to the feature extractor. We also recommend adding the sampling_rate argument in the feature extractor in order to better debug any silent errors that may occur.
audio_input = [dataset[0]["audio"]["array"]]
feature_extractor(audio_input, sampling_rate=16000)
{'input_values': [array([ 3.8106556e-04... |
[
0.017320957,
0.042829487,
0.027357794,
0.016516317,
-0.004160841,
-0.013368335,
-0.036872324,
-0.009232197,
-0.007587624,
0.05423563,
0.031169252,
-0.012429587,
0.0008818407,
-0.062451437,
-0.039610926,
0.04678211,
-0.010276819,
-0.07837486,
-0.029475272,
-0.026016727,
-0.011... | Just like the tokenizer, you can apply padding or truncation to handle variable sequences in a batch. Take a look at the sequence length of these two audio samples:
dataset[0]["audio"]["array"].shape
(173398,)
dataset[1]["audio"]["array"].shape
(106496,)
Create a function to preprocess the dataset so the audio sample... |
[
0.013053682,
0.045512784,
0.0206277,
-0.007937957,
-0.026642969,
-0.038865775,
-0.06037242,
-0.0007347417,
-0.013994426,
0.04814961,
0.050429374,
0.0017098194,
0.013259684,
-0.024541745,
-0.031669427,
0.061745767,
-0.050319504,
-0.06872238,
-0.053478207,
-0.03271317,
0.005122... | def preprocess_function(examples):
audio_arrays = [x["array"] for x in examples["audio"]]
inputs = feature_extractor(
audio_arrays,
sampling_rate=16000,
padding=True,
max_length=100000,
truncation=True,
)
return inputs
Apply the preprocess_function to th... |
[
0.01623439,
-0.033418316,
0.021232631,
-0.040302437,
0.021746961,
-0.018212587,
-0.03774397,
-0.012225248,
0.014269384,
0.039748542,
0.023751533,
0.00782706,
0.02292069,
-0.037110947,
0.022445925,
0.032811668,
-0.019333564,
-0.03241603,
-0.036082286,
-0.022393173,
-0.01730261... | Image preprocessing often follows some form of image augmentation. Both image preprocessing and image augmentation
transform image data, but they serve different purposes: |
[
0.02244043,
-0.004057625,
0.01138252,
-0.021396032,
-0.0062240437,
-0.015101422,
0.013132591,
-0.004438689,
-0.0061570047,
0.023597734,
-0.014776811,
-0.019631848,
0.06622044,
-0.025220785,
0.006562767,
0.038191073,
0.011072024,
-0.035848234,
-0.063002564,
-0.01235635,
-0.011... | from datasets import load_dataset
dataset = load_dataset("food101", split="train[:100]")
Next, take a look at the image with 🤗 Datasets Image feature:
dataset[0]["image"]
Load the image processor with [AutoImageProcessor.from_pretrained]:
from transformers import AutoImageProcessor
image_processor = AutoImageProce... |
[
0.02051123,
-0.0039160997,
-0.0005110247,
-0.0011107323,
0.017926253,
-0.01147786,
-0.0048433198,
-0.008661078,
-0.040629096,
0.034166653,
0.017940303,
-0.027254649,
0.018586546,
-0.033885676,
-0.012117079,
0.02712821,
-0.006241174,
-0.032171726,
-0.043270268,
-0.034588117,
-... | processed_dataset["input_values"][0].shape
(100000,)
processed_dataset["input_values"][1].shape
(100000,)
Computer vision
For computer vision tasks, you'll need an image processor to prepare your dataset for the model.
Image preprocessing consists of several steps that convert images into the input expected by the mod... |
[
0.04506913,
0.014515445,
0.029422065,
0.019614711,
-0.011812136,
-0.01656912,
-0.0032953133,
0.01346765,
-0.015758827,
0.059905898,
0.044705894,
0.0045683836,
0.012852944,
-0.018958094,
-0.035317656,
0.07834708,
-0.017421328,
-0.055100013,
-0.053926483,
0.009988973,
-0.010659... | Apply the preprocess_function to the first few examples in the dataset:
processed_dataset = preprocess_function(dataset[:5])
The sample lengths are now the same and match the specified maximum length. You can pass your processed dataset to the model now!
processed_dataset["input_values"][0].shape
(100000,)
processed... |
[
0.02749786,
-0.013604059,
-0.00056784187,
-0.03512772,
0.027856588,
-0.0193575,
-0.020392291,
-0.0030595337,
0.013576465,
0.04213671,
0.032533847,
-0.020061158,
0.025842194,
-0.033968758,
0.035569232,
0.04164001,
-0.0072090477,
-0.023786407,
-0.045999933,
-0.02620092,
-0.0397... |
Image augmentation alters images in a way that can help prevent overfitting and increase the robustness of the model. You can get creative in how you augment your data - adjust brightness and colors, crop, rotate, resize, zoom, etc. However, be mindful not to change the meaning of the images with your augmentations.
... |
[
0.059289575,
-0.005713524,
-0.0038624676,
-0.03544546,
-0.014975777,
0.00113643,
0.0068394956,
-0.0061178976,
0.01680243,
0.034218393,
-0.002999687,
-0.048887406,
0.04969615,
-0.03854101,
0.020093197,
0.048887406,
0.03299133,
-0.050978996,
-0.07563186,
-0.03522236,
0.01135732... | You can use any library you like for image augmentation. For image preprocessing, use the ImageProcessor associated with the model.
Load the food101 dataset (see the 🤗 Datasets tutorial for more details on how to load a dataset) to see how you can use an image processor with computer vision datasets:
Use 🤗 Datasets... |
[
0.030926632,
-0.02010665,
0.002307202,
-0.022059454,
0.000844859,
-0.005843947,
-0.014602635,
0.012816181,
0.009858045,
0.05757156,
0.03882464,
-0.035931595,
0.01325737,
-0.04032902,
0.008831014,
0.041254796,
-0.038535334,
-0.05366595,
-0.03266246,
0.016215507,
0.012548575,
... | Here we use Compose to chain together a couple of
transforms - RandomResizedCrop and ColorJitter.
Note that for resizing, we can get the image size requirements from the image_processor. For some models, an exact height and
width are expected, for others only the shortest_edge is defined. |
[
0.008760514,
0.0014564445,
0.0073077106,
-0.028750215,
0.0040744036,
-0.025575167,
0.0002958403,
0.0008725013,
0.012066643,
0.041625183,
0.012918663,
-0.023070082,
0.062860146,
-0.026259694,
0.00061034126,
0.0247013,
0.0049519115,
-0.046897516,
-0.022924436,
-0.0018842751,
-0... | Then use 🤗 Datasets[~datasets.Dataset.set_transform] to apply the transforms on the fly:
dataset.set_transform(transforms)
Now when you access the image, you'll notice the image processor has added pixel_values. You can pass your processed dataset to the model now!
dataset[0].keys()
Here is what the image looks li... |
[
0.024120841,
-0.02079778,
-0.0020983987,
-0.039590266,
-0.015985072,
0.011910024,
-0.028589787,
-0.014115849,
0.007920918,
0.016930424,
-0.019308133,
-0.026255049,
0.045548856,
-0.03394679,
0.046465565,
0.06365381,
0.00890208,
-0.040163208,
-0.056463394,
-0.026670432,
-0.0256... | Load the image processor with [AutoImageProcessor.from_pretrained]:
from transformers import AutoImageProcessor
image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
First, let's add some image augmentation. You can use any library you prefer, but in this tutorial, we'll use torchvision'... |
[
0.013163187,
-0.027901834,
-0.0028840483,
-0.012824536,
-0.017285885,
-0.0144957015,
-0.020966865,
0.011646623,
-0.0014696316,
0.068319,
0.029977906,
-0.037074838,
0.032569315,
-0.0321276,
0.006603679,
0.025840484,
-0.033953365,
-0.05630428,
-0.027990177,
0.004571778,
0.00553... | from torchvision.transforms import RandomResizedCrop, ColorJitter, Compose
size = (
image_processor.size["shortest_edge"]
if "shortest_edge" in image_processor.size
else (image_processor.size["height"], image_processor.size["width"])
)
_transforms = Compose([RandomResizedCrop(size), ColorJitter(brightne... |
[
0.03953887,
0.00283312,
0.011596357,
-0.020411301,
-0.012359464,
-0.05097833,
-0.026416304,
0.0027136619,
-0.028926708,
0.052632917,
0.006229655,
-0.010669219,
0.06093437,
-0.040794075,
-0.0036497146,
0.04575783,
-0.012637605,
-0.057197288,
-0.037085522,
-0.037827235,
-0.0027... | The model accepts pixel_values
as its input. ImageProcessor can take care of normalizing the images, and generating appropriate tensors.
Create a function that combines image augmentation and image preprocessing for a batch of images and generates pixel_values:
def transforms(examples):
images = [_transforms(img.... |
[
0.027429866,
-0.013405263,
0.009482779,
-0.019846397,
-0.017809456,
-0.04291336,
-0.012524425,
-0.001959522,
-0.030251304,
0.06798974,
0.03027883,
-0.013095594,
0.057309564,
-0.005116434,
-0.0046037585,
0.03738059,
0.009083649,
-0.036417175,
-0.053400844,
0.012214755,
-0.0472... | In the example above we set do_resize=False because we have already resized the images in the image augmentation transformation,
and leveraged the size attribute from the appropriate image_processor. If you do not resize images during image augmentation,
leave this parameter out. By default, ImageProcessor will handle ... |
[
0.014887261,
0.010367656,
0.029254695,
-0.01965234,
-0.03823615,
-0.03734089,
-0.034684,
-0.0028373878,
-0.02752194,
0.07768522,
0.008403867,
-0.001256248,
0.017038766,
-0.022251474,
-0.009306343,
0.041528385,
-0.009638455,
-0.05972232,
-0.050249923,
0.0021767747,
-0.01095968... | Pad
In some cases, for instance, when fine-tuning DETR, the model applies scale augmentation at training
time. This may cause images to be different sizes in a batch. You can use [DetrImageProcessor.pad]
from [DetrImageProcessor] and define a custom collate_fn to batch images together. |
[
0.009403085,
-0.012607254,
0.026080124,
0.024502471,
0.002834189,
-0.06841146,
0.011413544,
-0.022827089,
-0.0069947224,
0.02934712,
0.012816678,
-0.014052272,
0.022422204,
-0.039008494,
-0.015204098,
0.02064909,
-0.021961475,
-0.06913746,
-0.026540853,
-0.013221562,
-0.00403... | def collate_fn(batch):
pixel_values = [item["pixel_values"] for item in batch]
encoding = image_processor.pad(pixel_values, return_tensors="pt")
labels = [item["labels"] for item in batch]
batch = {}
batch["pixel_values"] = encoding["pixel_values"]
batch["pixel_mask"] = encoding["pixel_mas... |
[
0.020244436,
0.024027914,
0.011039853,
0.010573977,
-0.006698734,
-0.05127461,
-0.02322322,
-0.018310344,
-0.014138635,
0.02566554,
0.012783359,
0.0035470114,
0.004256414,
-0.052516945,
-0.018945629,
0.026159652,
-0.029872542,
-0.040601812,
-0.025594953,
-0.010637505,
-0.0243... | from datasets import load_dataset
lj_speech = load_dataset("lj_speech", split="train")
For ASR, you're mainly focused on audio and text so you can remove the other columns:
lj_speech = lj_speech.map(remove_columns=["file", "id", "normalized_text"])
Now take a look at the audio and text columns: |
[
0.02890135,
0.001114153,
0.019425496,
-0.022890106,
-0.0029463978,
-0.059520196,
-0.036659703,
0.0083135795,
-0.0050710617,
0.062836744,
0.011970666,
-0.032750916,
0.046224393,
-0.0051006735,
-0.010460452,
0.02223864,
-0.011304395,
-0.034912594,
-0.014295211,
0.013280999,
0.0... | dataset[0].keys()
Here is what the image looks like after the transforms are applied. The image has been randomly cropped and it's color properties are different.
import numpy as np
import matplotlib.pyplot as plt
img = dataset[0]["pixel_values"]
plt.imshow(img.permute(1, 2, 0)) |
[
0.03153459,
-0.0034034895,
-0.003471452,
-0.047988664,
-0.0030261187,
-0.054427214,
-0.03837376,
0.004739489,
0.003530472,
0.061695624,
-0.012404941,
-0.01967335,
0.029789029,
-0.007504489,
0.0019870084,
0.017598705,
-0.013771345,
-0.061466698,
-0.049676996,
0.0015497234,
-0.... | import numpy as np
import matplotlib.pyplot as plt
img = dataset[0]["pixel_values"]
plt.imshow(img.permute(1, 2, 0))
For tasks like object detection, semantic segmentation, instance segmentation, and panoptic segmentation, ImageProcessor
offers post processing methods. These methods convert model's raw outputs into me... |
[
0.005672576,
0.014628069,
0.0030996846,
0.019682234,
-0.0088257035,
-0.06865115,
0.0062222737,
-0.023072038,
0.025179213,
0.057229646,
0.0050885216,
0.011925388,
0.033501025,
-0.039333932,
-0.043395586,
-0.019865466,
-0.01609393,
-0.00050245813,
-0.029118713,
0.0052068597,
-0... |
lj_speech[0]["audio"]
{'array': array([-7.3242188e-04, -7.6293945e-04, -6.4086914e-04, ,
7.3242188e-04, 2.1362305e-04, 6.1035156e-05], dtype=float32),
'path': '/root/.cache/huggingface/datasets/downloads/extracted/917ece08c95cf0c4115e45294e3cd0dee724a1165b7fc11798369308a465bd26/LJSpeech-1.1/wavs/LJ001-000... |
[
0.02149738,
0.050280064,
-0.008640542,
0.0025455537,
-0.024580728,
-0.03983971,
-0.002896912,
-0.012476799,
0.0058870413,
0.025570268,
0.008518642,
-0.027936555,
0.038405593,
-0.045518804,
0.014728359,
0.038176134,
-0.05770878,
-0.041044366,
-0.03820482,
-0.037172254,
-0.0149... | Remember you should always resample your audio dataset's sampling rate to match the sampling rate of the dataset used to pretrain a model!
lj_speech = lj_speech.cast_column("audio", Audio(sampling_rate=16_000))
Load a processor with [AutoProcessor.from_pretrained]:
from transformers import AutoProcessor
processor = ... |
[
-0.00040875748,
0.028110147,
-0.00417942,
-0.0009902933,
-0.016004741,
-0.01792531,
0.00014015516,
-0.020224174,
-0.0071512097,
0.028168345,
-0.013429433,
-0.03422105,
0.035181332,
-0.026960716,
0.009020855,
0.051651668,
-0.045540765,
-0.061574608,
-0.061574608,
-0.050400387,
... | Load a processor with [AutoProcessor.from_pretrained]:
from transformers import AutoProcessor
processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
Create a function to process the audio data contained in array to input_values, and tokenize text to labels. These are the inputs to the model:
def pr... |
[
0.025646754,
0.031142486,
-0.037325185,
-0.0053848163,
0.002407961,
-0.011077336,
0.001782714,
-0.009402855,
0.022698522,
0.034147963,
-0.01776095,
-0.013939697,
-0.010683762,
-0.050950024,
0.012365399,
0.048831876,
-0.0364951,
-0.067379974,
-0.043536507,
-0.042305693,
0.0056... | Multimodal
For tasks involving multimodal inputs, you'll need a processor to prepare your dataset for the model. A processor couples together two processing objects such as as tokenizer and feature extractor.
Load the LJ Speech dataset (see the 🤗 Datasets tutorial for more details on how to load a dataset) to see how ... |
[
0.02089943,
0.04717095,
0.004772396,
0.0004991445,
-0.030279038,
-0.04372362,
-0.0087332325,
-0.0027291353,
0.0034545108,
0.03050886,
0.009753068,
-0.0096884305,
0.031198325,
-0.010629264,
-0.019103946,
0.048377514,
-0.053720873,
-0.059294056,
-0.049009524,
-0.04435563,
-0.01... | def prepare_dataset(example):
audio = example["audio"]
example.update(processor(audio=audio["array"], text=example["text"], sampling_rate=16000))
return example
Apply the prepare_dataset function to a sample:
prepare_dataset(lj_speech[0])
The processor has now added input_values and labels, and the s... |
[
0.040347125,
0.014080681,
-0.03203865,
-0.0069346623,
-0.0006158476,
-0.012462715,
0.021339666,
-0.020275597,
-0.022010174,
0.043495603,
-0.0035875854,
-0.027199328,
0.036440685,
-0.078420356,
0.0070549166,
0.047985096,
-0.0002564513,
-0.03486645,
-0.05489425,
-0.024400683,
0... |
How to convert a 🤗 Transformers model to TensorFlow?
Having multiple frameworks available to use with 🤗 Transformers gives you flexibility to play their strengths when
designing your application, but it implies that compatibility must be added on a per-model basis. The good news is that
adding TensorFlow compatibili... |
[
0.037053388,
0.01340011,
-0.04199566,
-0.0269504,
0.018635916,
-0.025025371,
0.03262992,
-0.01418514,
0.00036691592,
0.07132163,
0.0015461666,
-0.02049268,
0.042323325,
-0.04718368,
0.021530284,
0.029653631,
0.022199266,
-0.019414118,
-0.051006433,
0.0029831117,
0.016123822,
... | Step-by-step guide to add TensorFlow model architecture code
There are many ways to design a large model architecture, and multiple ways of implementing said design. However,
you might recall from our general overview of 🤗 Transformers
that we are an opinionated bunch - the ease of use of 🤗 Transformers relies on con... |
[
0.042111203,
-0.0053033167,
-0.047242522,
-0.0051384843,
0.021370934,
-0.03752455,
0.0065968963,
-0.0009666012,
0.03141857,
0.049793847,
0.021141602,
-0.016812949,
0.06105981,
-0.06358247,
-0.016110618,
0.018805275,
0.018403944,
-0.0016456407,
-0.07367311,
0.032622565,
0.0167... |
Don't reinvent the wheel! More often than not, there are at least two reference implementations you should check: the
PyTorch equivalent of the model you are implementing and other TensorFlow models for the same class of problems.
Great model implementations survive the test of time. This doesn't happen because the c... |
[
0.037669968,
0.021248985,
-0.068632774,
0.010841318,
-0.0034746425,
0.003149403,
0.008817606,
0.00912839,
0.036976125,
-0.014245492,
-0.038508363,
-0.034229655,
0.03769888,
-0.061405227,
0.0047340426,
-0.01225069,
0.0009793325,
-0.03128082,
-0.03631119,
-0.013269774,
0.021986... | Run training on Amazon SageMaker
The documentation has been moved to hf.co/docs/sagemaker. This page will be removed in transformers 5.0.
Table of Content
Train Hugging Face models on Amazon SageMaker with the SageMaker Python SDK
Deploy Hugging Face models to Amazon SageMaker with the SageMaker Python SDK |
[
0.017345842,
0.014235553,
-0.0428861,
-0.045248725,
0.03436271,
-0.02613839,
0.023222495,
-0.011170125,
-0.03783188,
0.054160897,
-0.0032093546,
-0.0196337,
0.0731516,
-0.04022441,
0.009764513,
0.021996323,
-0.0013962656,
0.011222461,
-0.06776841,
-0.019289773,
0.0034037477,
... | Before starting the work on a TensorFlow model architecture, double-check that there is no ongoing effort to do so.
You can search for BrandNewBert on the
pull request GitHub page to confirm that there is no
TensorFlow-related pull request.
2. Prepare transformers dev environment
Having selected the model architecture... |
[
0.01693165,
0.00961685,
-0.037077997,
0.00039970884,
-0.0014736869,
-0.009732634,
0.035361674,
-0.014275437,
-0.014956517,
0.072630376,
0.028714333,
0.008813175,
0.05617548,
-0.036478646,
-0.018034998,
0.035443403,
0.005438424,
-0.000015377509,
-0.051980026,
-0.027978767,
0.0... | Are you unsure whether the model you wish to use already has a corresponding TensorFlow architecture?
Check the model_type field of the config.json of your model of choice
(example). If the corresponding model folder in
🤗 Transformers has a file whose name starts with "modeling_tf", it means that it has a correspond... |
[
0.013112683,
0.048459914,
-0.031983543,
-0.06510732,
-0.0014350904,
-0.033209294,
0.024429498,
0.0040371385,
0.012278887,
0.008694279,
-0.026481919,
0.0053020846,
0.063282944,
-0.035746314,
0.015535679,
0.020267647,
0.0025637434,
-0.027579393,
-0.07645264,
-0.011088769,
0.003... | 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 transformers fork to your local disk, and add the base repository as a remote:
git clone https://github.com/[your Github handle]/transformers.git
cd transformers... |
[
0.034099646,
0.018769253,
-0.036180303,
-0.033146013,
0.030371802,
-0.016703047,
0.0062455814,
-0.005389478,
-0.034301933,
0.05528188,
0.0026784837,
-0.020445338,
0.057853807,
-0.054906208,
0.02635498,
0.054328248,
-0.003778414,
-0.030660782,
-0.046265706,
-0.0347643,
0.01253... |
Here's an overview of the steps needed to add a TensorFlow model architecture:
1. Select the model you wish to convert
2. Prepare transformers dev environment
3. (Optional) Understand theoretical aspects and the existing implementation
4. Implement the model architecture
5. Implement model tests
6. Submit the pull re... |
[
0.011439422,
0.003467687,
-0.039159402,
-0.008584945,
0.00060693483,
-0.036692217,
0.042716738,
0.009273463,
-0.011317497,
0.04220035,
-0.015161716,
0.00003678478,
0.041540522,
-0.020497723,
-0.0048160325,
0.009875915,
0.01471705,
-0.049228963,
-0.028128786,
0.008183311,
-0.0... | Push the changes to your account using:
git add .
git commit -m "initial commit"
git push -u origin add_tf_brand_new_bert
Once you are satisfied, go to the webpage of your fork on GitHub. Click on “Pull request”. Make sure to add the
GitHub handle of some members of the Hugging Face team as reviewers, so that the ... |
[
0.04810554,
-0.018664712,
-0.024767209,
-0.0074048596,
0.017786548,
-0.012882223,
0.0069322884,
-0.006601116,
-0.027476123,
0.06525207,
0.005886677,
-0.030036194,
0.059119806,
-0.043491457,
0.034382362,
0.02631516,
-0.0027907763,
-0.038222473,
-0.04066347,
-0.017622821,
0.002... |
Now you have set up a development environment to port BrandNewBert to TensorFlow in 🤗 Transformers.
3. (Optional) Understand theoretical aspects and the existing implementation
You should take some time to read BrandNewBert's paper, if such descriptive work exists. There might be large
sections of the paper that are... |
[
0.005167406,
0.015900806,
-0.054549586,
-0.0117013985,
-0.03271267,
-0.024399268,
0.019317273,
0.00364779,
-0.019075273,
0.039147016,
-0.0070962864,
-0.01380822,
0.066165574,
-0.04094066,
0.025395736,
0.04355995,
-0.011801045,
-0.036641605,
-0.05585923,
0.006338258,
0.0224063... | Set up a development environment, for instance by running the following command:
python -m venv .env
source .env/bin/activate
pip install -e ".[dev]"
Depending on your OS, and since the number of optional dependencies of Transformers is growing, you might get a
failure with this command. If that's the case make sure t... |
[
0.024456663,
0.011299948,
-0.027311096,
-0.007091047,
0.022655323,
-0.02995768,
0.028599747,
-0.0005412682,
-0.027144818,
0.04883019,
-0.0018602306,
-0.007967468,
0.052765425,
-0.050659243,
0.01121681,
0.015948793,
0.0057123285,
-0.038520977,
-0.033976056,
-0.02560675,
-0.006... | Add an empty .py file in transformers/src/models/brandnewbert/ named modeling_tf_brandnewbert.py. This will
be your TensorFlow model file.
Push the changes to your account using:
git add .
git commit -m "initial commit"
git push -u origin add_tf_brand_new_bert |
[
0.02181908,
0.013665483,
-0.045494493,
0.008831872,
0.0010611454,
-0.02694542,
0.02578878,
-0.0064364853,
-0.025603145,
0.052577123,
-0.023875326,
-0.012773015,
0.06739925,
-0.05269136,
0.022790084,
0.01976283,
-0.002116936,
-0.04523746,
-0.045494493,
-0.03472775,
0.014607931... | pip install -e ".[quality]"
Note: You don't need to have CUDA installed. Making the new model work on CPU is sufficient.
Create a branch with a descriptive name from your main branch
git checkout -b add_tf_brand_new_bert
Fetch and rebase to current main
git fetch upstream
git rebase upstream/main
Add an empty .py ... |
[
0.041332193,
0.026902437,
-0.03838198,
-0.0019388158,
-0.008653471,
-0.012246305,
0.019351644,
-0.001751689,
-0.0054549733,
0.020636886,
-0.0011601859,
0.002440863,
0.02734059,
-0.053337514,
0.007996246,
0.03654175,
0.015890256,
-0.05459355,
-0.058945842,
-0.012808599,
0.0121... |
Share a model
The last two tutorials showed how you can fine-tune a model with PyTorch, Keras, and 🤗 Accelerate for distributed setups. The next step is to share your model with the community! At Hugging Face, we believe in openly sharing knowledge and resources to democratize artificial intelligence for everyone. We... |
[
0.044118397,
0.019598352,
-0.022398116,
0.017373277,
0.007905651,
0.010985392,
0.023797998,
0.017388012,
0.02611149,
0.008509811,
-0.019082606,
0.01575236,
0.012694722,
-0.04662345,
-0.010027578,
0.015958657,
0.03126895,
-0.028690219,
-0.030885825,
-0.0018152421,
0.010219141,... | Programmatically push your files to the Hub.
Drag-and-drop your files to the Hub with the web interface.
To share a model with the community, you need an account on huggingface.co. You can also join an existing organization or create a new one. |
[
0.011685023,
-0.009253959,
-0.029635822,
0.0027457995,
0.0109759625,
-0.009080312,
0.027074523,
-0.009579548,
-0.013993086,
0.079472624,
-0.021257335,
0.006359836,
0.03779725,
-0.07663638,
0.02135863,
0.02229922,
0.035163596,
-0.030619824,
-0.051370688,
-0.024122518,
-0.00550... |
NVIDIA_TF32_OVERRIDE=0 RUN_SLOW=1 RUN_PT_TF_CROSS_TESTS=1 \
py.test -vv tests/models/brand_new_bert/test_modeling_tf_brand_new_bert.py
The most likely outcome is that you'll see a bunch of errors. Don't worry, this is expected! Debugging ML models is
notoriously hard, and the key ingredient to success is patience (an... |
[
0.019108849,
-0.000013756134,
-0.0016236748,
-0.061540883,
-0.010304923,
0.036456913,
0.00087362726,
-0.041883595,
-0.0054338984,
0.035879605,
-0.026916921,
-0.000093699564,
0.027537525,
-0.024275742,
-0.015818201,
0.025863336,
0.0090997955,
0.025242731,
-0.07539624,
0.01461307... |
Repository features
Each repository on the Model Hub behaves like a typical GitHub repository. Our repositories offer versioning, commit history, and the ability to visualize differences.
The Model Hub's built-in versioning is based on git and git-lfs. In other words, you can treat one model as one repository, enabli... |
[
-0.0054698433,
-0.011221675,
0.0018781121,
-0.022992864,
-0.03126451,
-0.019984992,
-0.0058458275,
-0.02148893,
0.007975198,
0.0659418,
0.028430171,
0.012834067,
0.02605858,
-0.031524807,
-0.00263008,
0.022168592,
0.013918636,
0.00039677153,
-0.082890004,
-0.0026246572,
0.013... | model = AutoModel.from_pretrained(
"julien-c/EsperBERTo-small", revision="v2.0.1" # tag name, or branch name, or commit hash
)
Files are also easily edited in a repository, and you can view the commit history as well as the difference: |
[
0.021852514,
0.0070612393,
-0.006341895,
0.0016875429,
0.0023835571,
-0.0066374093,
0.008717676,
-0.017264264,
0.027000686,
0.00071156764,
-0.0016817104,
0.0027471175,
0.055027895,
-0.058014147,
-0.011937227,
0.0362394,
0.004716566,
-0.0071701133,
-0.05362809,
-0.012924868,
0... | Files are also easily edited in a repository, and you can view the commit history as well as the difference:
Setup
Before sharing a model to the Hub, you will need your Hugging Face credentials. If you have access to a terminal, run the following command in the virtual environment where 🤗 Transformers is installed. T... |
[
0.023343457,
0.0019197857,
-0.050957058,
0.011429753,
0.0016902655,
-0.018276218,
0.0018085841,
-0.0009154122,
-0.016397355,
0.038260493,
-0.010291048,
0.0036829996,
0.05246584,
-0.073047936,
0.0071489336,
0.054942526,
-0.0011662832,
-0.046174496,
-0.060920727,
-0.018219283,
... |
NVIDIA_TF32_OVERRIDE=0 RUN_SLOW=1 RUN_PT_TF_CROSS_TESTS=1 \
py.test -vv tests/models/brand_new_bert/test_modeling_tf_brand_new_bert.py
and we will merge your PR! Congratulations on the milestone 🎉
7. (Optional) Build demos and share with the world
One of the hardest parts about open-source is discovery. How can the ... |
[
0.050954986,
-0.010324491,
-0.010246383,
0.012916266,
0.003603631,
-0.009436898,
0.04720579,
0.010246383,
-0.018774385,
0.0036639874,
-0.039508577,
0.009372991,
-0.01758146,
-0.038060024,
-0.039991427,
-0.013889069,
0.00044934437,
-0.036554664,
-0.004622589,
0.03348714,
0.016... | huggingface-cli login
If you are using a notebook like Jupyter or Colaboratory, make sure you have the huggingface_hub library installed. This library allows you to programmatically interact with the Hub.
pip install huggingface_hub
Then use notebook_login to sign-in to the Hub, and follow the link here to generate a ... |
[
0.017685587,
-0.02947598,
-0.013213865,
0.033990838,
-0.013472679,
-0.010431621,
-0.010489135,
-0.016334007,
0.0012374519,
0.07465331,
0.007714079,
-0.035975073,
0.060964953,
-0.039655976,
-0.0021370086,
0.00819576,
-0.030770047,
0.004996538,
-0.062345292,
-0.035428688,
-0.01... | Specify from_tf=True to convert a checkpoint from TensorFlow to PyTorch:
pt_model = DistilBertForSequenceClassification.from_pretrained("path/to/awesome-name-you-picked", from_tf=True)
pt_model.save_pretrained("path/to/awesome-name-you-picked")
``
</pt>
<tf>
Specifyfrom_pt=True` to convert a checkpoint from PyTorch to... |
[
0.026408978,
-0.011429219,
-0.018574314,
0.023562675,
-0.014605631,
-0.03301122,
-0.01613882,
-0.0064775352,
0.001909149,
0.046450455,
0.01898512,
-0.011275166,
0.05384497,
-0.041109975,
-0.014723005,
0.012492913,
-0.009815336,
-0.02120054,
-0.054197088,
-0.022344928,
-0.0000... | tf_model = TFDistilBertForSequenceClassification.from_pretrained("path/to/awesome-name-you-picked", from_pt=True)
Then you can save your new TensorFlow model with its new checkpoint:
tf_model.save_pretrained("path/to/awesome-name-you-picked")
If a model is available in Flax, you can also convert a checkpoint from Py... |
[
0.053487755,
0.043280814,
-0.032284386,
0.0013084693,
-0.028153677,
-0.0032566346,
0.01063693,
0.0024794831,
0.0012952525,
0.03352501,
0.018454263,
0.02596849,
0.014062741,
-0.040771373,
0.005498214,
0.032030623,
0.007471932,
-0.007880774,
-0.060621336,
-0.0054488713,
-0.0003... | Push a model during training
Sharing a model to the Hub is as simple as adding an extra parameter or callback. Remember from the fine-tuning tutorial, the [TrainingArguments] class is where you specify hyperparameters and additional training options. One of these training options includes the ability to push a model d... |
[
0.025300452,
-0.015794996,
-0.029128248,
0.018769009,
-0.0054072957,
-0.016463792,
0.00026791907,
-0.020063912,
0.010850166,
0.073311545,
0.0044147726,
-0.01868363,
0.048580285,
-0.068359606,
-0.010031956,
0.028658668,
0.004525053,
-0.008196322,
-0.0477265,
-0.0143862525,
0.0... |
Convert a model for all frameworks
To ensure your model can be used by someone working with a different framework, we recommend you convert and upload your model with both PyTorch and TensorFlow checkpoints. While users are still able to load your model from a different framework if you skip this step, it will be slo... |
[
0.032237727,
0.03910541,
-0.001568795,
-0.0009098001,
-0.052571464,
-0.025531633,
0.032587845,
0.019606572,
-0.017559731,
0.026043342,
0.00714374,
0.04942041,
0.004423598,
-0.053648748,
0.004938674,
0.032749437,
0.018057974,
-0.005113733,
-0.06776117,
0.013694975,
-0.00803923... | training_args = TrainingArguments(output_dir="my-awesome-model", push_to_hub=True)
Pass your training arguments as usual to [Trainer]:
trainer = Trainer(
model=model,
args=training_args,
train_dataset=small_train_dataset,
eval_dataset=small_eval_dataset,
compute_metrics=compute_metrics,
) |
[
0.024827756,
0.02485698,
-0.017345818,
0.0067074397,
0.0010329676,
-0.00063932565,
0.00967391,
-0.0019581632,
0.017243527,
0.041852083,
-0.008855574,
0.015022326,
-0.0077011343,
-0.019800829,
0.0043474142,
0.041384462,
0.0138971135,
-0.027677322,
-0.0644148,
-0.0070764218,
0.... | trainer.push_to_hub()
``
</pt>
<tf>
Share a model to the Hub with [PushToHubCallback]. In the [PushToHubCallback`] function, add:
An output directory for your model.
A tokenizer.
The hub_model_id, which is your Hub username and model name.
from transformers import PushToHubCallback
push_to_hub_callback = PushToHubCal... |
[
0.037854344,
0.03420848,
-0.029907497,
0.015124648,
-0.002745081,
0.00410516,
0.00056210073,
-0.0054723597,
0.023299364,
0.040959027,
-0.0017606259,
0.013465494,
0.019781671,
-0.044206128,
0.004525289,
0.044775795,
0.035547197,
-0.013593669,
-0.050928194,
-0.003156309,
-0.009... | from transformers import PushToHubCallback
push_to_hub_callback = PushToHubCallback(
output_dir="./your_model_save_path", tokenizer=tokenizer, hub_model_id="your-username/my-awesome-model"
)
Add the callback to fit, and 🤗 Transformers will push the trained model to the Hub:
model.fit(tf_train_dataset, validati... |
[
0.019149734,
0.0020418605,
-0.028483953,
-0.017093288,
-0.018230896,
0.029213188,
-0.005046312,
-0.0040946594,
0.019703953,
0.028031826,
0.0131772915,
0.008167442,
0.0018431436,
-0.026631694,
0.0010619498,
0.04588352,
0.026062889,
0.00062030624,
-0.065689564,
-0.010763521,
0.... | from transformers import AutoModel
model = AutoModel.from_pretrained("your_username/my-awesome-model")
If you belong to an organization and want to push your model under the organization name instead, just add it to the repo_id:
pt_model.push_to_hub("my-awesome-org/my-awesome-model")
The push_to_hub function can als... |
[
0.038222916,
0.012724614,
-0.04147593,
0.018059837,
-0.013250424,
0.010340939,
0.0004469389,
0.0065025226,
0.013818299,
0.05294561,
0.005191502,
-0.0036911895,
0.011518755,
-0.045261767,
-0.015003125,
0.017092345,
0.018859068,
-0.025603464,
-0.0490476,
-0.013005045,
0.0117641... | The push_to_hub function can also be used to add other files to a model repository. For example, add a tokenizer to a model repository:
tokenizer.push_to_hub("my-awesome-model")
Or perhaps you'd like to add the TensorFlow version of your fine-tuned PyTorch model:
tf_model.push_to_hub("my-awesome-model") |
[
0.01220403,
0.022172738,
-0.021214742,
-0.014841989,
-0.036292758,
0.000790086,
-0.011433468,
0.008406758,
-0.00046598152,
0.008531714,
0.025602084,
0.037042495,
-0.00851783,
-0.0477054,
0.019076606,
0.036792584,
0.017535483,
-0.02297801,
-0.07680625,
0.007448762,
-0.00533145... | trainer = Trainer(
model=model,
args=training_args,
train_dataset=small_train_dataset,
eval_dataset=small_eval_dataset,
compute_metrics=compute_metrics,
)
After you fine-tune your model, call [~transformers.Trainer.push_to_hub] on [Trainer] to push the trained model to the Hub. 🤗 Transformer... |
[
0.01807214,
0.014556898,
-0.014272469,
-0.00488998,
-0.033022862,
-0.02679461,
0.0415703,
0.01441833,
0.030163992,
0.014002627,
-0.0052072266,
-0.0036410475,
0.020055845,
-0.016336398,
-0.0076285144,
0.017765833,
0.044487514,
-0.027844807,
-0.059802886,
-0.0052765105,
0.00313... | Now when you navigate to your Hugging Face profile, you should see your newly created model repository. Clicking on the Files tab will display all the files you've uploaded to the repository.
For more details on how to create and upload files to a repository, refer to the Hub documentation here.
Upload with the web int... |
[
0.022303859,
0.0026159072,
-0.029699426,
-0.015669815,
-0.019228475,
0.002418204,
0.0066926223,
-0.0047412175,
0.038720552,
0.024031932,
0.025701426,
-0.0058542136,
0.014842391,
-0.019667815,
-0.0071722358,
0.053043056,
0.02152769,
-0.00877949,
-0.079315625,
-0.01287268,
0.00... | Use the push_to_hub function
You can also call push_to_hub directly on your model to upload it to the Hub.
Specify your model name in push_to_hub:
pt_model.push_to_hub("my-awesome-model")
This creates a repository under your username with the model name my-awesome-model. Users can now load your model with the from_pr... |
[
0.019242387,
0.0038754994,
-0.019654825,
-0.029809346,
0.013390028,
0.00514837,
-0.0139233535,
-0.008668318,
0.029439574,
0.043348704,
0.01742197,
-0.0072958944,
0.054185882,
-0.019100167,
0.009649638,
0.06206488,
0.026424507,
-0.044315804,
-0.06928966,
-0.016796201,
0.026253... | From here, add some information about your model:
Select the owner of the repository. This can be yourself or any of the organizations you belong to.
Pick a name for your model, which will also be the repository name.
Choose whether your model is public or private.
Specify the license usage for your model.
Now click ... |
[
0.035997156,
0.028516324,
-0.04115155,
0.015588553,
0.008267923,
0.007870896,
0.003611557,
-0.013979547,
0.02227533,
0.029588996,
0.015296006,
0.014529812,
0.00813558,
-0.044912864,
0.004482231,
0.03889476,
0.042711798,
-0.020269297,
-0.05901082,
-0.002798347,
-0.019837443,
... | Add the callback to fit, and 🤗 Transformers will push the trained model to the Hub:
model.fit(tf_train_dataset, validation_data=tf_validation_dataset, epochs=3, callbacks=push_to_hub_callback)
Use the push_to_hub function
You can also call push_to_hub directly on your model to upload it to the Hub.
Specify your mode... |
[
-0.014890342,
0.035165075,
-0.01937271,
-0.01849844,
-0.032445125,
-0.029919457,
-0.01983066,
0.007923938,
0.0019740458,
0.054593295,
0.0029419875,
-0.00585622,
0.019344956,
-0.034054894,
-0.012579772,
0.024687715,
-0.0039029904,
-0.050430104,
-0.0017710903,
0.0055058184,
0.0... | The majority of the optimizations described here also apply to multi-GPU setups!
FlashAttention-2
FlashAttention-2 is experimental and may change considerably in future versions.
FlashAttention-2 is a faster and more efficient implementation of the standard attention mechanism that can significantly speedup inferenc... |
[
0.006421833,
0.03563803,
-0.025505649,
-0.010894056,
-0.018364066,
0.0032895298,
-0.029628478,
0.015596879,
0.04044567,
0.062219806,
-0.029460771,
0.025323965,
0.008811677,
-0.030746534,
-0.0026745992,
0.08256842,
0.008070965,
-0.027588027,
-0.0008699872,
-0.002117318,
0.0524... | FlashAttention-2 is currently supported for the following architectures:
* Bark
* Bart
* DistilBert
* Gemma
* GPTBigCode
* GPTNeo
* GPTNeoX
* Falcon
* Llama
* Llava
* VipLlava
* MBart
* Mistral
* Mixtral
* OPT
* Phi
* StableLm
* Starcoder2
* Qwen2
* Whisper
You can request to add FlashAttention-2 support for another mo... |
[
0.021045055,
0.04345049,
0.0023364502,
-0.022419037,
-0.019113319,
-0.0022395232,
0.010760594,
-0.0009913759,
0.016106881,
0.06388337,
0.00977432,
0.002375561,
0.0478037,
-0.017589694,
0.0042681876,
0.028731193,
0.051449515,
-0.052347366,
-0.05925809,
-0.019494224,
0.01238624... | Now click on the Files tab and click on the Add file button to upload a new file to your repository. Then drag-and-drop a file to upload and add a commit message.
Add a model card
To make sure users understand your model's capabilities, limitations, potential biases and ethical considerations, please add a model card ... |
[
-0.0018647657,
0.01523428,
0.022616142,
-0.037409276,
-0.0061209165,
0.019395769,
0.030292103,
-0.021483865,
0.01448433,
0.09228798,
0.039026815,
0.0072090793,
0.061584137,
-0.010602236,
0.017248852,
0.02123388,
0.015101937,
-0.032586068,
-0.08087697,
-0.003823275,
0.01425640... | Manually creating and uploading a README.md file.
Clicking on the Edit model card button in your model repository.
Take a look at the DistilBert model card for a good example of the type of information a model card should include. For more details about other options you can control in the README.md file such as a mod... |
[
0.028287435,
0.010595685,
-0.038398985,
-0.0250368,
0.008465482,
0.002617798,
0.0049209073,
-0.005757773,
0.011902855,
0.053144414,
0.031565733,
-0.038924616,
0.0128642125,
-0.031455074,
0.0027198128,
0.048275378,
0.0030310436,
-0.044789594,
-0.008368654,
0.015976522,
0.00559... |
GPU inference
GPUs are the standard choice of hardware for machine learning, unlike CPUs, because they are optimized for memory bandwidth and parallelism. To keep up with the larger sizes of modern models or to run these large models on existing and older hardware, there are several optimizations you can use to speed ... |
[
-0.006410152,
0.07333648,
-0.04068817,
-0.025328249,
-0.04823911,
-0.036722567,
0.0029606211,
0.026591266,
0.033816267,
0.063721254,
-0.037021343,
0.012630172,
0.031290233,
-0.02045273,
0.017234074,
0.030937131,
0.01568586,
-0.03487557,
-0.010178832,
-0.025056632,
0.05130838,... | pip install flash-attn --no-build-isolation
We strongly suggest referring to the detailed installation instructions to learn more about supported hardware and data types!
FlashAttention-2 is also supported on AMD GPUs and current support is limited to Instinct MI210 and Instinct MI250. We strongly suggest using this D... |
[
0.002726124,
0.03491721,
-0.01720186,
-0.0073742634,
-0.041421395,
0.008130232,
-0.009692092,
0.018742325,
0.0020093797,
0.049893953,
0.0015627518,
-0.011660465,
0.023934262,
-0.032577984,
0.019983254,
0.0716031,
-0.0069071315,
-0.019084651,
-0.00598,
-0.020311316,
-0.0007581... | To enable FlashAttention-2, pass the argument attn_implementation="flash_attention_2" to [~AutoModelForCausalLM.from_pretrained]:
thon
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, LlamaForCausalLM
model_id = "tiiuae/falcon-7b"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = Aut... |
[
-0.020741273,
0.0046292427,
0.0072608623,
0.01996206,
-0.05601844,
-0.0027608986,
-0.0037118946,
0.021251304,
0.024892362,
0.059843674,
-0.010767328,
-0.00836593,
0.05182485,
-0.01406128,
0.028080057,
0.06262051,
0.019168677,
-0.051796515,
-0.028320905,
-0.008769705,
0.043239... | FlashAttention-2 can only be used when the model's dtype is fp16 or bf16. Make sure to cast your model to the appropriate dtype and load them on a supported device before using FlashAttention-2.
You can also set use_flash_attention_2=True to enable FlashAttention-2 but it is deprecated in favor of attn_implementation=... |
[
-0.007223572,
0.03991496,
-0.019090371,
-0.015635923,
-0.037845086,
-0.021160241,
-0.006597716,
0.011657014,
0.0026327928,
0.07093506,
0.013621993,
-0.025383899,
0.026866375,
-0.029873284,
-0.010426279,
0.05918714,
0.010146567,
-0.05666973,
0.00885989,
0.0071326657,
0.0312998... | You can also set use_flash_attention_2=True to enable FlashAttention-2 but it is deprecated in favor of attn_implementation="flash_attention_2".
FlashAttention-2 can be combined with other optimization techniques like quantization to further speedup inference. For example, you can combine FlashAttention-2 with 8-bit o... |
[
0.048175175,
0.045190345,
0.013536209,
0.04778715,
-0.042653237,
0.00409295,
-0.0059062345,
-0.0011640842,
-0.025012886,
0.058323603,
0.026908252,
0.042862177,
-0.005227186,
-0.05074213,
-0.042832326,
0.017461263,
0.01343174,
-0.0707405,
-0.0019289472,
0.0014392483,
-0.020371... | For a single forward pass on meta-llama/Llama-7b-hf with a sequence length of 4096 and various batch sizes without padding tokens, the expected speedup is:
For sequences with padding tokens (generating with padding tokens), you need to unpad/pad the input sequences to correctly compute the attention scores. With a rel... |
[
0.030163357,
0.009900024,
-0.0051531442,
-0.008823779,
-0.02647134,
0.006222261,
-0.0077404077,
-0.0031663685,
-0.017918402,
0.048038993,
0.028096396,
-0.013385346,
0.002809996,
-0.051659737,
0.00003939585,
0.04675605,
-0.012829405,
-0.031759903,
-0.03221606,
-0.020954695,
-0... | import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, LlamaForCausalLM
model_id = "tiiuae/falcon-7b"
tokenizer = AutoTokenizer.from_pretrained(model_id)
load in 8bit
model = AutoModelForCausalLM.from_pretrained(
model_id,
load_in_8bit=True,
attn_implementation="flash_attention_2",
)
lo... |
[
-0.02306838,
0.0351465,
-0.013821501,
0.008228744,
-0.032189734,
-0.016861953,
-0.0006990946,
-0.0037691835,
0.016666695,
0.06432368,
-0.00505231,
0.0058298563,
0.008709917,
-0.049762983,
-0.00042887102,
-0.003277551,
0.0036366868,
-0.045550983,
-0.028870342,
-0.007168771,
0.... | But for larger sequence lengths, you can expect even more speedup benefits:
FlashAttention is more memory efficient, meaning you can train on much larger sequence lengths without running into out-of-memory issues. You can potentially reduce memory usage up to 20x for larger sequence lengths. Take a look at the flash-a... |
[
0.029516954,
0.025507761,
-0.03454297,
-0.011323064,
0.0048553357,
0.019334186,
-0.026059752,
-0.03248027,
-0.00252935,
0.038581215,
-0.009558148,
0.015455728,
0.03126008,
-0.0236339,
-0.010509605,
0.064728126,
-0.004288819,
-0.0048117572,
0.00013493348,
-0.0017358642,
0.0184... |
PyTorch scaled dot product attention
PyTorch's torch.nn.functional.scaled_dot_product_attention (SDPA) can also call FlashAttention and memory-efficient attention kernels under the hood. SDPA support is currently being added natively in Transformers and is used by default for torch>=2.1.1 when an implementation is av... |
[
0.0004482085,
0.060546618,
0.00994299,
-0.007415358,
-0.05483577,
-0.01882248,
-0.011662071,
0.012259379,
0.0077504334,
0.06654883,
-0.008588121,
0.018327152,
0.004519872,
-0.035197455,
-0.032895636,
0.022114959,
0.0050261267,
-0.059148043,
0.0006838082,
-0.00081902195,
0.019... |
Expected speedups
You can benefit from considerable speedups for inference, especially for inputs with long sequences. However, since FlashAttention-2 does not support computing attention scores with padding tokens, you must manually pad/unpad the attention scores for batched inference when the sequence contains padd... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.