vector listlengths 1.02k 1.02k | text stringlengths 2 11.8k |
|---|---|
[
0.03166661,
0.021009017,
-0.016387325,
0.039393727,
-0.055518623,
-0.0060614147,
0.0070892675,
0.018807517,
-0.01787443,
0.07237249,
0.0025058466,
0.010234788,
0.040064383,
0.007967681,
-0.00825198,
0.009505815,
-0.0059775827,
-0.039976906,
-0.02778847,
0.008652915,
-0.000469... | [T5ForConditionalGeneration] is supported by this example script and notebook.
[TFT5ForConditionalGeneration] is supported by this example script and notebook.
Translation task guide
A notebook on how to finetune T5 for question answering with TensorFlow 2. 🌎
A notebook on how to finetune T5 for question answering on... |
[
0.026591789,
0.00831269,
-0.07549775,
0.03539692,
-0.029737528,
-0.0023942164,
-0.005879887,
0.033985745,
-0.00887128,
0.048509065,
0.0018365459,
0.008283291,
0.0059019364,
-0.01872744,
-0.016257888,
0.0041894196,
-0.03892485,
-0.051713604,
-0.03427974,
0.014611519,
0.0108189... | A notebook on how to finetune T5 for question answering with TensorFlow 2. 🌎
A notebook on how to finetune T5 for question answering on a TPU.
🚀 Deploy
- A blog post on how to deploy T5 11B for inference for less than $500.
T5Config
[[autodoc]] T5Config
T5Tokenizer
[[autodoc]] T5Tokenizer
- build_inputs_with_spe... |
[
0.008602015,
-0.00295778,
-0.02497532,
0.024908327,
-0.019535417,
0.012186187,
-0.004260811,
0.014417084,
-0.014551071,
0.05675722,
0.02048673,
0.0026596573,
0.036257092,
-0.018476913,
-0.013854335,
-0.005205425,
-0.027346903,
-0.049548678,
-0.05686441,
-0.008782898,
0.015381... | T5Model
[[autodoc]] T5Model
- forward
T5ForConditionalGeneration
[[autodoc]] T5ForConditionalGeneration
- forward
T5EncoderModel
[[autodoc]] T5EncoderModel
- forward
T5ForSequenceClassification
[[autodoc]] T5ForSequenceClassification
- forward
T5ForTokenClassification
[[autodoc]] T5ForTokenClassificatio... |
[
-0.0024711252,
0.04156352,
0.031516977,
-0.028249148,
-0.028384183,
-0.02900534,
-0.025548466,
0.0031176014,
0.047234952,
0.06341205,
-0.01260544,
0.013645203,
0.00416918,
-0.032894325,
-0.023293395,
0.06535654,
-0.03011262,
-0.024711253,
-0.01932339,
0.02141642,
0.03864678,
... | OpenAI GPT2 |
[
0.03446541,
0.022219907,
-0.0051636733,
0.026700718,
-0.01496161,
-0.010258293,
-0.024030646,
-0.03133498,
-0.004611245,
0.04155491,
-0.015851634,
-0.0047186613,
0.021161087,
-0.037626527,
-0.027943682,
0.0054168697,
-0.0021751877,
0.001150893,
-0.003611886,
-0.0016735903,
0.... |
GPT-2 is a model with absolute position embeddings so it's usually advised to pad the inputs on the right rather than
the left.
GPT-2 was trained with a causal language modeling (CLM) objective and is therefore powerful at predicting the next
token in a sequence. Leveraging this feature allows GPT-2 to generate s... |
[
0.04965146,
0.005662457,
-0.0033514737,
0.007747088,
-0.007615658,
-0.026096223,
0.047110476,
0.0010432283,
0.021802833,
0.042466603,
-0.023511427,
-0.005019909,
0.034288716,
-0.060750023,
-0.0084626535,
0.02191966,
0.03370458,
-0.028082281,
-0.016195139,
0.0054762643,
0.0040... | Resources
A list of official Hugging Face and community (indicated by 🌎) resources to help you get started with GPT2. If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicat... |
[
-0.0011704173,
-0.019420257,
-0.030913878,
0.04583294,
-0.021585926,
-0.022902314,
-0.0022399821,
0.001187226,
0.009667665,
0.048833735,
0.027828153,
0.011514854,
0.047361646,
-0.010757577,
-0.0063483855,
0.016037282,
-0.0041190195,
-0.031480066,
-0.05916667,
0.04096372,
0.02... | TFT5Model
[[autodoc]] TFT5Model
- call
TFT5ForConditionalGeneration
[[autodoc]] TFT5ForConditionalGeneration
- call
TFT5EncoderModel
[[autodoc]] TFT5EncoderModel
- call
FlaxT5Model
[[autodoc]] FlaxT5Model
- call
- encode
- decode
FlaxT5ForConditionalGeneration
[[autodoc]] FlaxT5ForConditionalGe... |
[
0.01140965,
0.022192886,
-0.00024842087,
-0.026339138,
-0.023490455,
-0.015555901,
0.0010971534,
-0.014437308,
0.006025488,
0.071232006,
-0.0007378053,
-0.004381156,
0.024116866,
-0.03364728,
-0.01838967,
0.04659313,
-0.023535198,
-0.010924926,
-0.0404185,
0.005637709,
0.0401... |
Overview
OpenAI GPT-2 model was proposed in Language Models are Unsupervised Multitask Learners by Alec
Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei and Ilya Sutskever from OpenAI. It's a causal (unidirectional)
transformer pretrained using language modeling on a very large corpus of ~40 GB of text data... |
[
0.012579086,
-0.021762425,
0.005615784,
-0.0033805873,
-0.00431206,
0.016507104,
0.0059492947,
0.0068925577,
0.0253064,
0.08376176,
0.020697886,
0.026815621,
0.037838325,
-0.010948589,
-0.032825552,
0.07481424,
-0.017827671,
-0.049777336,
-0.015388663,
-0.017625544,
0.0156446... | GPT2Model
[[autodoc]] GPT2Model
- forward
GPT2LMHeadModel
[[autodoc]] GPT2LMHeadModel
- forward
GPT2DoubleHeadsModel
[[autodoc]] GPT2DoubleHeadsModel
- forward
GPT2ForQuestionAnswering
[[autodoc]] GPT2ForQuestionAnswering
- forward
GPT2ForSequenceClassification
[[autodoc]] GPT2ForSequenceClassification
... |
[
-0.0048240097,
-0.023651049,
0.008368317,
0.01475343,
0.027818456,
-0.01979184,
0.0041540083,
0.0038692579,
0.00952742,
0.064105734,
-0.0056816116,
0.009259419,
0.048079297,
-0.026424855,
-0.026411453,
0.056172915,
-0.003425382,
-0.06523133,
-0.0492049,
-0.012944426,
0.017085... | TFGPT2Model
[[autodoc]] TFGPT2Model
- call
TFGPT2LMHeadModel
[[autodoc]] TFGPT2LMHeadModel
- call
TFGPT2DoubleHeadsModel
[[autodoc]] TFGPT2DoubleHeadsModel
- call
TFGPT2ForSequenceClassification
[[autodoc]] TFGPT2ForSequenceClassification
- call
TFSequenceClassifierOutputWithPast
[[autodoc]] modeling_tf... |
[
0.035112742,
0.011097772,
-0.0035500547,
0.004352849,
-0.009807502,
-0.02922679,
0.031256426,
-0.012337301,
0.000080641876,
0.046971627,
-0.017295416,
0.011242745,
0.029313775,
-0.04511596,
-0.022036072,
0.027124664,
0.0023594543,
-0.04117266,
-0.025384976,
0.023862746,
-0.01... |
A blog on how to Finetune a non-English GPT-2 Model with Hugging Face.
A blog on How to generate text: using different decoding methods for language generation with Transformers with GPT-2.
A blog on Training CodeParrot 🦜 from Scratch, a large GPT-2 model.
A blog on Faster Text Generation with TensorFlow and XLA wit... |
[
0.0017387266,
-0.01729255,
-0.010621793,
0.023327352,
-0.0051383767,
-0.021284178,
0.015168191,
-0.0005928246,
0.01702193,
0.045924034,
0.007516441,
-0.0024355703,
0.027210733,
-0.06018565,
-0.010141444,
0.05463796,
-0.019119227,
-0.021703638,
-0.0589408,
0.002171717,
0.00620... | GPT2Config
[[autodoc]] GPT2Config
GPT2Tokenizer
[[autodoc]] GPT2Tokenizer
- save_vocabulary
GPT2TokenizerFast
[[autodoc]] GPT2TokenizerFast
GPT2 specific outputs
[[autodoc]] models.gpt2.modeling_gpt2.GPT2DoubleHeadsModelOutput
[[autodoc]] models.gpt2.modeling_tf_gpt2.TFGPT2DoubleHeadsModelOutput |
[
0.042126,
-0.014776527,
0.038028367,
-0.028270701,
-0.008497424,
0.03301688,
0.03979713,
0.005851652,
0.0041418495,
0.06909961,
0.01599255,
0.028064346,
0.0054721055,
-0.0040497263,
-0.02051763,
0.01643474,
-0.017156985,
-0.008541644,
-0.022979157,
0.0148944445,
-0.007266661,... | [~transformers.BrosModel.forward] requires input_ids and bbox (bounding box). Each bounding box should be in (x0, y0, x1, y1) format (top-left corner, bottom-right corner). Obtaining of Bounding boxes depends on external OCR system. The x coordinate should be normalized by document image width, and the y coordinate sho... |
[
0.031691503,
-0.04077317,
-0.0053695,
-0.014242313,
0.029562566,
-0.020144047,
0.0041938694,
0.032149628,
0.031475917,
0.089361414,
0.032176577,
0.015454997,
0.024078537,
-0.026301792,
-0.005106752,
0.085480824,
0.003991755,
-0.052387994,
-0.02084471,
0.024994787,
0.039695226... | FlaxGPT2Model
[[autodoc]] FlaxGPT2Model
- call
FlaxGPT2LMHeadModel
[[autodoc]] FlaxGPT2LMHeadModel
- call |
[
0.026279815,
0.017014027,
-0.0012895495,
-0.00901043,
-0.01727668,
-0.026673792,
0.0168827,
0.00007073598,
-0.005070647,
0.049612086,
0.01727668,
0.031518266,
0.016094744,
-0.03259806,
-0.037033964,
0.008514309,
-0.012505164,
-0.011563994,
-0.015219237,
-0.0070989057,
0.00931... | [~transformers.BrosForTokenClassification.forward, ~transformers.BrosSpadeEEForTokenClassification.forward, ~transformers.BrosSpadeEEForTokenClassification.forward] require not only input_ids and bbox but also box_first_token_mask for loss calculation. It is a mask to filter out non-first tokens of each box. You can ob... |
[
0.061084025,
-0.0062672268,
-0.012228736,
-0.011147536,
0.0046417,
0.011662038,
0.0024513395,
-0.01996863,
-0.027112002,
0.06555795,
0.005130104,
-0.00027682426,
-0.0034766146,
-0.014749048,
-0.034210633,
-0.0012927786,
-0.049183376,
-0.048228938,
-0.026590044,
-0.011371233,
... |
BROS
Overview
The BROS model was proposed in BROS: A Pre-trained Language Model Focusing on Text and Layout for Better Key Information Extraction from Documents by Teakgyu Hong, Donghyun Kim, Mingi Ji, Wonseok Hwang, Daehyun Nam, Sungrae Park.
BROS stands for BERT Relying On Spatiality. It is an encoder-only Transform... |
[
-0.00435551,
0.01570634,
0.023308432,
0.026391115,
0.02079765,
-0.05412131,
-0.021341652,
-0.0005222079,
0.011751858,
0.09507497,
0.0009947232,
0.04723061,
0.009206203,
-0.053981826,
-0.024535926,
0.015887674,
-0.015455262,
-0.053284384,
-0.039335594,
0.0141580235,
0.00326053... | box_end_token_indices = np.array(list(itertools.accumulate(tokens_length_list)))
box_start_token_indices = box_end_token_indices - np.array(tokens_length_list)
# filter out the indices that are out of max_seq_length
box_end_token_indices = box_end_token_indices[box_end_token_indices < max_seq_length - 1]
if len(box_st... |
[
0.028428778,
-0.0050745225,
0.044919185,
-0.0032959345,
-0.0062304256,
-0.02513642,
0.0038720968,
0.02170092,
-0.0020183574,
0.08331092,
0.06161,
0.023619074,
0.015488387,
-0.011408729,
-0.043230064,
0.02924471,
-0.00455204,
-0.03850625,
-0.022359392,
0.024921702,
-0.00574015... | thon
def expand_and_normalize_bbox(bboxes, doc_width, doc_height):
# here, bboxes are numpy array
# Normalize bbox -> 0 ~ 1
bboxes[:, [0, 2]] = bboxes[:, [0, 2]] / width
bboxes[:, [1, 3]] = bboxes[:, [1, 3]] / height |
[
0.013512248,
0.0041289376,
0.005954252,
0.002966575,
0.0067948108,
-0.061448723,
-0.012358678,
-0.005975354,
0.011824097,
0.07467258,
0.0030474656,
0.07017084,
0.047859102,
-0.036829844,
-0.0040410133,
0.033847444,
-0.015362181,
-0.021523936,
-0.008089061,
0.026982293,
-0.018... | # set box_start_token_indices to True
box_first_token_mask[box_start_token_indices] = True
return box_first_token_mask
Resources
Demo scripts can be found here. |
[
0.03393548,
0.0057019675,
0.019103644,
0.000630129,
-0.019477054,
-0.059327345,
-0.0030264864,
0.018237334,
0.00440997,
0.044271465,
-0.0020294823,
0.056698542,
0.036773395,
-0.025451612,
-0.047736708,
0.015242588,
-0.02516782,
-0.03265095,
-0.04920047,
-0.0029480702,
0.00819... | thon
def make_box_first_token_mask(bboxes, words, tokenizer, max_seq_length=512):
box_first_token_mask = np.zeros(max_seq_length, dtype=np.bool_)
# encode(tokenize) each word from words (List[str])
input_ids_list: List[List[int]] = [tokenizer.encode(e, add_special_tokens=False) for e in words]
# get the length of eac... |
[
0.0046222475,
0.011083785,
0.012264226,
-0.0072610807,
-0.014645696,
-0.04233114,
-0.0079405205,
0.014165284,
0.0063963393,
0.08735258,
0.012621104,
0.056935657,
-0.019051759,
-0.044444952,
-0.029071774,
0.024610808,
0.0031346867,
-0.045103803,
-0.023787245,
-0.0004821275,
0.... | # get the length of each box
tokens_length_list: List[int] = [len(l) for l in input_ids_list]
box_end_token_indices = np.array(list(itertools.accumulate(tokens_length_list)))
box_start_token_indices = box_end_token_indices - np.array(tokens_length_list) |
[
0.038497847,
-0.0101922555,
-0.015701963,
-0.00698527,
-0.01969755,
-0.026735393,
0.0053554904,
0.017342256,
-0.007647697,
0.07183648,
0.012253138,
0.03659118,
0.04197471,
-0.028165394,
-0.038077258,
0.052769806,
-0.014524315,
-0.035806082,
-0.019893825,
0.0033839832,
0.00560... | return box_first_token_mask
Resources
Demo scripts can be found here.
BrosConfig
[[autodoc]] BrosConfig
BrosProcessor
[[autodoc]] BrosProcessor
- call
BrosModel
[[autodoc]] BrosModel
- forward
BrosForTokenClassification
[[autodoc]] BrosForTokenClassification
- forward
BrosSpadeEEForTokenClassification
[[... |
[
0.027241835,
-0.0116112735,
-0.031693302,
0.01084055,
0.020701488,
-0.018122807,
-0.0231073,
-0.025052115,
-0.0075847837,
0.035006694,
0.03428639,
-0.0115680555,
-0.0038320085,
-0.071914986,
0.0071814144,
-0.013325593,
-0.01519838,
-0.0035132747,
-0.041748725,
-0.016711015,
0... |
Overview
The RoBERTa model was proposed in RoBERTa: A Robustly Optimized BERT Pretraining Approach by Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer
Levy, Mike Lewis, Luke Zettlemoyer, Veselin Stoyanov. It is based on Google's BERT model released in 2018.
It builds on BERT and modifies ... |
[
0.011288853,
-0.008090106,
-0.0103851715,
0.0069676754,
0.016696602,
-0.016051114,
-0.009223294,
0.0006656586,
-0.008735593,
0.050749637,
0.014028588,
0.025475226,
-0.010951766,
-0.06196677,
-0.035171878,
-0.014480429,
-0.014774485,
-0.03445467,
-0.04111036,
-0.017628971,
-0.... | This implementation is the same as [BertModel] with a tiny embeddings tweak as well as a setup
for Roberta pretrained models.
RoBERTa has the same architecture as BERT, but uses a byte-level BPE as a tokenizer (same as GPT-2) and uses a
different pretraining scheme.
RoBERTa doesn't have token_type_ids, you don't ne... |
[
0.030288631,
-0.000720968,
-0.020192422,
0.014470763,
0.019015476,
-0.015612259,
0.03791751,
0.00040413204,
0.013825569,
0.024574064,
-0.006384577,
0.011372417,
0.014378592,
-0.07384981,
0.0007338187,
-0.022574672,
0.026942136,
-0.03332317,
-0.031082716,
-0.019270716,
0.00245... | Resources
A list of official Hugging Face and community (indicated by 🌎) resources to help you get started with RoBERTa. If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of dupli... |
[
-0.032441005,
-0.01760128,
-0.008691631,
0.008168389,
0.015740864,
-0.010392168,
0.00031112914,
0.0019821425,
0.021612803,
-0.038196668,
0.034388628,
0.002123854,
-0.017703021,
-0.041946568,
-0.02706324,
-0.04683016,
-0.027310327,
-0.03252821,
-0.03842922,
0.0010364916,
0.015... | RoBERTa |
[
0.011947839,
-0.0074031358,
-0.023169072,
-0.013599834,
0.0072454764,
-0.012379688,
-0.0017702405,
-0.008280545,
0.020660233,
0.045488156,
-0.009288194,
0.0126744425,
0.0025414005,
-0.072605565,
-0.020303784,
-0.020221528,
0.0057511395,
-0.027295634,
-0.020797327,
-0.022168279,... |
A blog on Getting Started with Sentiment Analysis on Twitter using RoBERTa and the Inference API.
A blog on Opinion Classification with Kili and Hugging Face AutoTrain using RoBERTa.
A notebook on how to finetune RoBERTa for sentiment analysis. 🌎
[RobertaForSequenceClassification] is supported by this example script... |
[
0.014406431,
-0.025635181,
-0.036821183,
0.0021036095,
-0.023796972,
-0.025749179,
-0.020932786,
-0.0140858125,
-0.016401386,
0.033258762,
0.020576544,
-0.001290487,
0.007438335,
-0.044943504,
0.00947604,
-0.02255725,
-0.033714753,
-0.04602648,
-0.029525345,
-0.024138965,
0.0... | Same as BERT with better pretraining tricks:
dynamic masking: tokens are masked differently at each epoch, whereas BERT does it once and for all
together to reach 512 tokens (so the sentences are in an order than may span several documents)
train with larger batches
use BPE with bytes as a subunit and not characters (... |
[
0.026141645,
-0.018575445,
-0.03822773,
-0.015585804,
0.0053345957,
-0.015047386,
0.013063738,
-0.018306237,
-0.006018246,
0.033353623,
0.034203757,
0.04236505,
0.0367825,
-0.06302333,
-0.031483326,
0.028082786,
0.007877916,
-0.05687402,
-0.018603783,
-0.011505158,
0.01524575... | A blog on How to train a new language model from scratch using Transformers and Tokenizers with RoBERTa.
[RobertaForMaskedLM] is supported by this example script and notebook.
[TFRobertaForMaskedLM] is supported by this example script and notebook.
[FlaxRobertaForMaskedLM] is supported by this example script and notebo... |
[
0.031952217,
-0.012487968,
-0.020518474,
0.02145242,
-0.056036662,
0.009693211,
-0.015735548,
0.028032482,
0.0016750859,
0.044914234,
0.03432953,
0.032518245,
0.032433342,
-0.037074763,
-0.044093497,
0.009226238,
-0.011157805,
-0.041631278,
-0.04191429,
-0.015961958,
-0.01478... |
Multiple choice
- [RobertaForMultipleChoice] is supported by this example script and notebook.
- [TFRobertaForMultipleChoice] is supported by this example script and notebook.
- Multiple choice task guide
RobertaConfig
[[autodoc]] RobertaConfig
RobertaTokenizer
[[autodoc]] RobertaTokenizer
- build_inputs_with_spe... |
[
-0.004906321,
-0.010680382,
-0.017798463,
0.0016294597,
-0.0051672957,
0.004296293,
-0.010452029,
0.0066613746,
-0.009388559,
0.04721029,
0.04600981,
0.031186456,
0.010980503,
-0.041729826,
-0.03032524,
0.0019100073,
-0.016624076,
-0.05193393,
-0.023539903,
-0.041416656,
0.03... |
RobertaModel
[[autodoc]] RobertaModel
- forward
RobertaForCausalLM
[[autodoc]] RobertaForCausalLM
- forward
RobertaForMaskedLM
[[autodoc]] RobertaForMaskedLM
- forward
RobertaForSequenceClassification
[[autodoc]] RobertaForSequenceClassification
- forward
RobertaForMultipleChoice
[[autodoc]] RobertaFo... |
[
0.017396735,
-0.016615657,
0.000386101,
0.009955193,
-0.024951888,
-0.01574937,
0.011119708,
0.03149874,
-0.009813178,
0.04584217,
0.016232219,
0.053993784,
0.037889376,
-0.02094709,
-0.043853972,
0.016530449,
0.008755173,
-0.036071595,
-0.0035041994,
-0.018689064,
-0.0168854... | [RobertaForTokenClassification] is supported by this example script and notebook.
[TFRobertaForTokenClassification] is supported by this example script and notebook.
[FlaxRobertaForTokenClassification] is supported by this example script.
Token classification chapter of the 🤗 Hugging Face Course.
Token classification ... |
[
0.0010300728,
-0.04141765,
-0.002123896,
0.0019041249,
-0.0022295876,
-0.027083868,
-0.009186774,
0.033418648,
-0.0071467594,
0.06721309,
0.05502669,
0.02898967,
0.021205408,
-0.007086364,
-0.048396647,
0.028801775,
-0.022466995,
-0.06340148,
-0.022198573,
0.0058247764,
0.055... |
FlaxRobertaModel
[[autodoc]] FlaxRobertaModel
- call
FlaxRobertaForCausalLM
[[autodoc]] FlaxRobertaForCausalLM
- call
FlaxRobertaForMaskedLM
[[autodoc]] FlaxRobertaForMaskedLM
- call
FlaxRobertaForSequenceClassification
[[autodoc]] FlaxRobertaForSequenceClassification
- call
FlaxRobertaForMultipleChoi... |
[
0.032609146,
-0.011277209,
-0.040826533,
0.005305858,
-0.027994098,
0.01208014,
-0.015827155,
0.023610527,
-0.005761576,
0.028789796,
0.02191786,
0.016550515,
0.0010660543,
-0.03553153,
-0.0237986,
0.0020868985,
-0.0025534667,
-0.034403082,
-0.022062533,
-0.01283967,
0.013808... | A blog on Accelerated Inference with Optimum and Transformers Pipelines with RoBERTa for question answering.
[RobertaForQuestionAnswering] is supported by this example script and notebook.
[TFRobertaForQuestionAnswering] is supported by this example script and notebook.
[FlaxRobertaForQuestionAnswering] is supported by... |
[
-0.006926367,
-0.030295419,
0.008959828,
0.017065672,
0.004724909,
0.007356859,
-0.010597796,
0.017975654,
-0.009764812,
0.06725471,
0.06199081,
0.033655353,
0.024583528,
-0.007853849,
-0.04986704,
0.0416072,
-0.0067023714,
-0.03583931,
-0.031331398,
-0.005508894,
0.026767485... |
TFRobertaModel
[[autodoc]] TFRobertaModel
- call
TFRobertaForCausalLM
[[autodoc]] TFRobertaForCausalLM
- call
TFRobertaForMaskedLM
[[autodoc]] TFRobertaForMaskedLM
- call
TFRobertaForSequenceClassification
[[autodoc]] TFRobertaForSequenceClassification
- call
TFRobertaForMultipleChoice
[[autodoc]] TFR... |
[
0.034282543,
-0.02413408,
-0.017422762,
0.017570915,
0.0153486235,
0.0036834476,
0.011644806,
-0.030934293,
-0.0071039237,
0.07223927,
-0.012741135,
-0.005529801,
0.015793081,
-0.036415942,
0.005922406,
-0.010215132,
-0.013348562,
-0.04382358,
-0.047290355,
-0.0097188195,
0.0... |
LED
Overview
The LED model was proposed in Longformer: The Long-Document Transformer by Iz
Beltagy, Matthew E. Peters, Arman Cohan.
The abstract from the paper is the following:
Transformer-based models are unable to process long sequences due to their self-attention operation, which scales
quadratically with the sequ... |
[
0.030915525,
0.005575525,
-0.0161973,
0.013195651,
-0.0064383177,
-0.017893882,
0.0009824234,
-0.019314952,
0.020373505,
0.048548393,
0.027536858,
-0.010687027,
0.03506273,
-0.03947095,
0.012137098,
0.011767331,
0.015936285,
-0.0283634,
-0.054203674,
-0.03123454,
0.02794288,
... |
Swin Transformer V2
Overview
The Swin Transformer V2 model was proposed in Swin Transformer V2: Scaling Up Capacity and Resolution by Ze Liu, Han Hu, Yutong Lin, Zhuliang Yao, Zhenda Xie, Yixuan Wei, Jia Ning, Yue Cao, Zheng Zhang, Li Dong, Furu Wei, Baining Guo.
The abstract from the paper is the following:
Large-sca... |
[
0.019730471,
-0.022977432,
0.0056752735,
-0.030258914,
-0.0020949808,
-0.013222732,
0.026321111,
0.023916978,
0.0067978934,
0.0922966,
0.028200204,
-0.010148481,
0.032939386,
0.011136386,
-0.026542181,
0.030507619,
0.020904904,
-0.048939306,
-0.018625122,
-0.047143113,
0.0235... | [Swinv2ForImageClassification] is supported by this example script and notebook.
See also: Image classification task guide
Besides that:
[Swinv2ForMaskedImageModeling] is supported by this example script. |
[
0.024801306,
-0.043492354,
-0.031502414,
-0.007875604,
-0.028490517,
-0.0013294134,
0.0018770308,
0.017307593,
0.0037288424,
0.06692462,
0.010332677,
-0.0029290328,
0.011060432,
-0.02997485,
-0.0063552447,
-0.0065569985,
-0.028014956,
-0.010181361,
-0.06185195,
0.0041539664,
... | This model was contributed by patrickvonplaten.
Resources
A notebook showing how to evaluate LED.
A notebook showing how to fine-tune LED.
Text classification task guide
Question answering task guide
Translation task guide
Summarization task guide |
[
0.03130005,
-0.023042567,
-0.02405617,
-0.017623171,
-0.018096186,
-0.016771745,
0.0009882626,
0.015974378,
0.0012112552,
0.07908804,
0.023488551,
0.0002557235,
0.03946293,
-0.021055905,
-0.000019414187,
0.027705139,
0.029570168,
-0.026461786,
-0.03940887,
-0.03730058,
0.0122... | If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
Swinv2Config
[[autodoc]] Swinv2Config
Swinv2Model
[[autodoc]] Swinv2Model
- forward
Swinv... |
[
0.042012457,
-0.021433681,
-0.05275983,
0.021204688,
-0.021174155,
-0.008526147,
0.006667493,
-0.017342351,
0.013205224,
0.06509488,
-0.029143088,
-0.013342619,
0.02984533,
-0.03621132,
0.012983864,
-0.008770405,
-0.038043257,
-0.056026787,
-0.058377773,
0.0032917645,
-0.0013... |
[LEDForConditionalGeneration] is an extension of
[BartForConditionalGeneration] exchanging the traditional self-attention layer with
Longformer's chunked self-attention layer. [LEDTokenizer] is an alias of
[BartTokenizer].
LED works very well on long-range sequence-to-sequence tasks where the input_ids largely ... |
[
-0.007330559,
-0.032801148,
-0.020100366,
0.015033859,
-0.01928586,
-0.020555938,
-0.008938865,
0.028079769,
-0.008062235,
0.06979907,
-0.026519783,
0.008096748,
0.008365949,
-0.07581814,
-0.0060294196,
0.010402216,
-0.026795886,
-0.048014473,
-0.06333824,
0.0054392475,
0.000... |
LEDConfig
[[autodoc]] LEDConfig
LEDTokenizer
[[autodoc]] LEDTokenizer
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
LEDTokenizerFast
[[autodoc]] LEDTokenizerFast
LED specific outputs
[[autodoc]] models.led.modeling_led.LEDEncoderB... |
[
-0.017853333,
-0.041567333,
-0.02181471,
0.004266621,
-0.035788063,
0.00430732,
-0.0009682991,
0.0267393,
0.002435162,
0.06365337,
0.00084535393,
0.0059183254,
0.03771449,
-0.03494695,
-0.0043039285,
0.03198948,
-0.00846541,
-0.038365673,
-0.04769933,
-0.004348019,
-0.0123114... | LEDModel
[[autodoc]] LEDModel
- forward
LEDForConditionalGeneration
[[autodoc]] LEDForConditionalGeneration
- forward
LEDForSequenceClassification
[[autodoc]] LEDForSequenceClassification
- forward
LEDForQuestionAnswering
[[autodoc]] LEDForQuestionAnswering
- forward
TFLEDModel
[[autodoc]] TFLEDModel
... |
[
0.018859457,
-0.05358048,
-0.046630826,
-0.008980045,
0.054616116,
-0.0064727184,
-0.01576618,
-0.021271396,
0.012291351,
0.06284669,
0.04673984,
0.0012332231,
0.06251965,
-0.010697018,
-0.017469525,
0.0042549605,
-0.004217487,
-0.055297453,
-0.052299563,
-0.016883574,
0.0307... | UPerNet framework. Taken from the original paper.
This model was contributed by nielsr. The original code is based on OpenMMLab's mmsegmentation here.
Usage examples
UPerNet is a general framework for semantic segmentation. It can be used with any vision backbone, like so: |
[
0.015033304,
-0.041811824,
-0.025069864,
-0.029722005,
0.033254184,
-0.022442268,
0.003740378,
-0.024294509,
0.0081627825,
0.0774208,
0.045717325,
-0.010366806,
0.05861122,
-0.019340841,
-0.005517237,
0.0008843912,
-0.0017714746,
-0.028429745,
-0.03489105,
-0.022858663,
0.007... |
UPerNet
Overview
The UPerNet model was proposed in Unified Perceptual Parsing for Scene Understanding
by Tete Xiao, Yingcheng Liu, Bolei Zhou, Yuning Jiang, Jian Sun. UPerNet is a general framework to effectively segment
a wide range of concepts from images, leveraging any vision backbone like ConvNeXt or Swin.
The ab... |
[
-0.0065867705,
-0.023629414,
-0.029722713,
-0.045942906,
-0.008188765,
0.019009378,
-0.020654282,
0.006289973,
-0.0015930545,
0.0703161,
0.030666746,
-0.032955308,
0.047029972,
-0.03999264,
0.033498842,
0.041880704,
-0.043625735,
-0.036102083,
-0.07340566,
-0.02247083,
-0.001... | from transformers import SwinConfig, UperNetConfig, UperNetForSemanticSegmentation
backbone_config = SwinConfig(out_features=["stage1", "stage2", "stage3", "stage4"])
config = UperNetConfig(backbone_config=backbone_config)
model = UperNetForSemanticSegmentation(config)
To use another vision backbone, like ConvNeXt, si... |
[
0.0008385381,
-0.0258988,
-0.025340935,
-0.03679108,
-0.0028712521,
0.024294943,
-0.006865204,
0.012963346,
0.0033907623,
0.06002608,
0.019385746,
-0.04429434,
0.045242704,
-0.029622536,
0.034448054,
0.047864664,
-0.037739445,
-0.056623116,
-0.07352637,
-0.012217204,
-0.01421... | To use another vision backbone, like ConvNeXt, simply instantiate the model with the appropriate backbone:
from transformers import ConvNextConfig, UperNetConfig, UperNetForSemanticSegmentation
backbone_config = ConvNextConfig(out_features=["stage1", "stage2", "stage3", "stage4"])
config = UperNetConfig(backbone_confi... |
[
0.024849555,
-0.027993893,
-0.029187944,
-0.00068782386,
-0.029320616,
-0.028736858,
-0.008504306,
0.0062654577,
0.03619305,
0.073076,
0.03247822,
0.010368354,
0.0486908,
-0.0296921,
-0.02039176,
0.012411511,
0.011787949,
-0.019874336,
-0.035848103,
-0.021068389,
0.013486157,... | If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
UperNetConfig
[[autodoc]] UperNetConfig
UperNetForSemanticSegmentation
[[autodoc]] UperNetFor... |
[
0.035074342,
-0.0063513196,
-0.013485022,
-0.037229583,
0.0013414903,
-0.018555744,
0.032653384,
0.007203821,
0.007462155,
0.048330553,
0.03442482,
-0.0016690205,
0.033657197,
-0.06825916,
-0.017241932,
0.041628636,
-0.023943849,
-0.054530565,
-0.0209767,
-0.017699553,
0.0028... | Note that this will randomly initialize all the weights of the model.
Resources
A list of official Hugging Face and community (indicated by 🌎) resources to help you get started with UPerNet.
Demo notebooks for UPerNet can be found here.
[UperNetForSemanticSegmentation] is supported by this example script and notebook... |
[
0.013796223,
0.030966256,
-0.031554222,
0.0142581975,
-0.014181201,
-0.034522057,
0.013607234,
0.024512619,
-0.015735114,
0.030966256,
-0.012858276,
-0.016953046,
0.058180723,
-0.06260447,
-0.013355248,
0.012823278,
-0.006691623,
-0.048381276,
-0.050285168,
-0.016547069,
0.00... |
from transformers import BlenderbotTokenizer, BlenderbotForConditionalGeneration
mname = "facebook/blenderbot-400M-distill"
model = BlenderbotForConditionalGeneration.from_pretrained(mname)
tokenizer = BlenderbotTokenizer.from_pretrained(mname)
UTTERANCE = "My friends are cool but they eat too many carbs."
inputs = t... |
[
0.029005354,
-0.0039211786,
-0.043401953,
-0.00073356344,
0.00040561464,
-0.056858983,
-0.008054517,
-0.0020231009,
-0.009448714,
0.038188867,
0.016427275,
-0.0023375528,
0.021337273,
-0.024125665,
-0.018745884,
0.015730176,
0.01516189,
-0.010903528,
-0.06376935,
-0.00887285,
... |
Blenderbot
Overview
The Blender chatbot model was proposed in Recipes for building an open-domain chatbot Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu,
Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston on 30 Apr 2020.
The abstract of the paper is the following:... |
[
-0.002814676,
-0.0010440688,
-0.03735075,
0.0115964655,
-0.0034585332,
-0.012222731,
-0.007472965,
0.017746532,
-0.019547924,
0.066313766,
-0.011343144,
0.0010423097,
0.018422054,
-0.07526444,
-0.003986285,
0.019716805,
-0.0070578,
-0.034789395,
-0.07498297,
0.008612908,
-0.0... | Resources
Causal language modeling task guide
Translation task guide
Summarization task guide
BlenderbotConfig
[[autodoc]] BlenderbotConfig
BlenderbotTokenizer
[[autodoc]] BlenderbotTokenizer
- build_inputs_with_special_tokens
BlenderbotTokenizerFast
[[autodoc]] BlenderbotTokenizerFast
- build_inputs_with_spe... |
[
0.015977424,
-0.016411897,
-0.017855471,
0.005493991,
-0.0075962837,
-0.00039023804,
0.005672686,
0.03021695,
0.0074771536,
0.053089894,
0.032739703,
0.017505089,
0.05440733,
-0.02772223,
-0.013833085,
0.024358563,
0.013580809,
-0.036355644,
-0.05379066,
0.010924913,
0.025003... | TFBlenderbotModel
[[autodoc]] TFBlenderbotModel
- call
TFBlenderbotForConditionalGeneration
[[autodoc]] TFBlenderbotForConditionalGeneration
- call
FlaxBlenderbotModel
[[autodoc]] FlaxBlenderbotModel
- call
- encode
- decode
FlaxBlenderbotForConditionalGeneration
[[autodoc]] FlaxBlenderbotForCondit... |
[
0.02212369,
-0.0022575194,
-0.019569872,
-0.02215191,
-0.010991299,
0.005146439,
0.0035132647,
0.009791991,
-0.009347542,
0.072014876,
0.0205011,
-0.0056226347,
0.023830941,
-0.04712572,
0.0047019897,
0.042751774,
0.015238257,
-0.029234877,
-0.061065905,
-0.017495776,
0.00647... | BlenderbotModel
See [~transformers.BartModel] for arguments to forward and generate
[[autodoc]] BlenderbotModel
- forward
BlenderbotForConditionalGeneration
See [~transformers.BartForConditionalGeneration] for arguments to forward and generate
[[autodoc]] BlenderbotForConditionalGeneration
- forward
BlenderbotF... |
[
0.040217906,
-0.01916265,
-0.037024133,
-0.0020349226,
-0.017698837,
-0.022178993,
-0.032854483,
-0.044653706,
-0.007925293,
0.027590668,
0.035900395,
0.0009033319,
0.00037034298,
-0.038295727,
0.0012503407,
-0.009647862,
-0.02219378,
-0.0039515574,
-0.038975883,
-0.005304476,
... |
Splinter
Overview
The Splinter model was proposed in Few-Shot Question Answering by Pretraining Span Selection by Ori Ram, Yuval Kirstain, Jonathan Berant, Amir Globerson, Omer Levy. Splinter
is an encoder-only transformer (similar to BERT) pretrained using the recurring span selection task on a large corpus
comprisin... |
[
0.0155987535,
-0.0085625965,
-0.0071851667,
0.0036380133,
0.020904947,
-0.008090127,
-0.020919485,
-0.019378508,
-0.0061966158,
0.07012897,
-0.033552583,
-0.017037967,
0.035791364,
-0.055969432,
-0.030645082,
0.031517334,
-0.0007464106,
-0.0048119174,
-0.07071047,
-0.034308534,... | Implementation Notes
Blenderbot uses a standard seq2seq model transformer based architecture.
Available checkpoints can be found in the model hub.
This is the default Blenderbot model class. However, some smaller checkpoints, such as
facebook/blenderbot_small_90M, have a different architecture and consequently shoul... |
[
0.032432668,
-0.018475039,
-0.04201768,
-0.008093689,
-0.010330674,
-0.003550943,
-0.029884389,
0.011402111,
-0.032432668,
0.04010647,
0.0110618565,
0.0019673165,
-0.0015827215,
-0.021935489,
-0.009896307,
-0.009838392,
-0.023600558,
-0.024990529,
-0.026496332,
0.01666518,
0.... |
Splinter was trained to predict answers spans conditioned on a special [QUESTION] token. These tokens contextualize
to question representations which are used to predict the answers. This layer is called QASS, and is the default
behaviour in the [SplinterForQuestionAnswering] class. Therefore:
Use [SplinterTokeni... |
[
-0.005840556,
-0.021016726,
-0.048924185,
-0.0035778792,
-0.035831798,
-0.010753514,
-0.005151483,
0.008560407,
-0.0035447506,
0.05009031,
0.008944698,
0.047493033,
0.021295007,
-0.060320392,
-0.019678336,
0.029418116,
-0.027721938,
-0.03283698,
-0.047360517,
-0.0042636395,
0... | SplinterConfig
[[autodoc]] SplinterConfig
SplinterTokenizer
[[autodoc]] SplinterTokenizer
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
SplinterTokenizerFast
[[autodoc]] SplinterTokenizerFast
SplinterModel
[[autodoc]] SplinterModel
... |
[
0.010759911,
0.026709724,
-0.014283197,
0.012536174,
-0.018522836,
-0.004287152,
-0.05239609,
-0.03529134,
-0.018742127,
0.042045522,
0.02551093,
-0.032045823,
0.030496161,
-0.07561176,
0.030203773,
0.0125873415,
-0.020891186,
0.00076295226,
-0.031928867,
-0.021475963,
0.0070... |
SEW-D
Overview
SEW-D (Squeezed and Efficient Wav2Vec with Disentangled attention) was proposed in Performance-Efficiency Trade-offs
in Unsupervised Pre-training for Speech Recognition by Felix Wu, Kwangyoun Kim,
Jing Pan, Kyu Han, Kilian Q. Weinberger, Yoav Artzi.
The abstract from the paper is the following:
This pap... |
[
-0.005871546,
0.006630106,
-0.010466669,
-0.00013391045,
-0.02313608,
0.01229013,
-0.044988442,
-0.022158705,
-0.003599513,
0.037694596,
0.03515634,
-0.011334636,
0.04367555,
-0.05662942,
0.016921723,
0.009773754,
-0.029467138,
-0.008789085,
-0.038219754,
-0.011225229,
-0.017... | SEW-D is a speech model that accepts a float array corresponding to the raw waveform of the speech signal.
SEWDForCTC is fine-tuned using connectionist temporal classification (CTC) so the model output has to be decoded
using [Wav2Vec2CTCTokenizer].
Resources
Audio classification task guide
Automatic speech recogni... |
[
0.0038401503,
0.0098647345,
-0.030999474,
0.022512186,
-0.01946511,
0.018894652,
-0.018685948,
0.008362067,
-0.0032488229,
0.05153593,
0.02710367,
-0.0027340201,
0.035145722,
-0.04215817,
0.017725911,
0.029942041,
-0.021357358,
-0.015151897,
-0.04630442,
-0.026032323,
-0.0002... | Resources
Audio classification task guide
Automatic speech recognition task guide
SEWDConfig
[[autodoc]] SEWDConfig
SEWDModel
[[autodoc]] SEWDModel
- forward
SEWDForCTC
[[autodoc]] SEWDForCTC
- forward
SEWDForSequenceClassification
[[autodoc]] SEWDForSequenceClassification
- forward |
[
0.054471683,
0.0128149465,
-0.05042417,
0.016777592,
-0.032693453,
0.018971082,
-0.005092032,
0.014649383,
-0.0063389265,
0.059380922,
-0.0004647295,
-0.0051899552,
0.002870796,
-0.03930004,
0.004096474,
-0.015772242,
-0.016281445,
0.0022718294,
-0.021386532,
-0.04010954,
0.0... | Resources
Question answering task guide |
[
0.051983368,
0.009528238,
-0.0014298111,
0.03578076,
-0.014775674,
-0.01798244,
-0.030379891,
-0.0031300494,
-0.005565811,
0.04290009,
0.023460027,
0.027479993,
-0.011937149,
-0.027326558,
-0.014744988,
0.010794068,
0.003989279,
0.023644147,
-0.017338019,
-0.007710048,
0.0142... |
TAPAS is a model that uses relative position embeddings by default (restarting the position embeddings at every cell of the table). Note that this is something that was added after the publication of the original TAPAS paper. According to the authors, this usually results in a slightly better performance, and allows ... |
[
0.016111983,
0.032799393,
-0.013472207,
-0.008430019,
-0.060189765,
0.0074086348,
-0.035877932,
0.025836715,
-0.01148698,
0.038755074,
0.013465014,
0.03173485,
-0.0022100029,
-0.019291222,
-0.014097985,
-0.00440562,
-0.013364314,
-0.000112613045,
-0.03679862,
0.008559491,
-0.... | Usage: fine-tuning
Here we explain how you can fine-tune [TapasForQuestionAnswering] on your own dataset.
STEP 1: Choose one of the 3 ways in which you can use TAPAS - or experiment
Basically, there are 3 different ways in which one can fine-tune [TapasForQuestionAnswering], corresponding to the different datasets on w... |
[
0.04125832,
-0.0019307067,
-0.005322084,
0.016104827,
-0.0059026065,
-0.003580515,
-0.02668158,
-0.027445622,
-0.017048646,
0.043745205,
0.01066664,
0.020254629,
-0.019940024,
-0.028449366,
-0.006142306,
0.0016544901,
-0.01006739,
0.0038501774,
-0.022846384,
-0.0067378106,
0.... |
TAPAS
Overview
The TAPAS model was proposed in TAPAS: Weakly Supervised Table Parsing via Pre-training
by Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno and Julian Martin Eisenschlos. It's a BERT-based model specifically
designed (and pre-trained) for answering questions about tabular data.... |
[
0.031818215,
-0.0080331,
-0.033817563,
0.030332984,
-0.012367403,
-0.021792907,
-0.022021404,
0.01379551,
0.015452113,
0.06980585,
0.027776673,
0.00032913394,
0.017894175,
-0.0146238115,
-0.048784122,
0.0015048673,
-0.032246646,
-0.023478072,
-0.06392205,
0.013517029,
0.03476... |
To summarize:
| Task | Example dataset | Description |
|-------------------------------------|---------------------|---------------------------------------------------------------------------------------... |
[
0.03522998,
0.029850552,
-0.015475274,
0.005552715,
-0.04632034,
0.018202659,
-0.024636878,
0.013689665,
-0.012182822,
0.055964135,
0.034928612,
0.0040797764,
-0.014684182,
-0.056054547,
0.001087752,
0.0653367,
-0.01666568,
0.008468456,
-0.03755052,
-0.03236698,
-0.010020504,... |
from transformers import TapasConfig, TapasForQuestionAnswering
for example, the base sized model with default SQA configuration
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base")
or, the base sized model with WTQ configuration
config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq"... |
[
-0.0025454422,
0.012705999,
0.006190374,
-0.086545035,
-0.012776705,
-0.0044509885,
-0.018567586,
-0.023248373,
0.028296832,
0.0055540134,
0.045563415,
-0.017252441,
0.0049530063,
-0.033034183,
-0.012486808,
0.045026045,
-0.050060365,
-0.010323183,
-0.058714867,
-0.03580589,
... | Initializing a model with a pre-trained base and randomly initialized classification heads from the hub can be done as shown below. |
[
0.03441897,
-0.024478365,
-0.03268757,
0.011470502,
-0.007761433,
-0.0053024017,
-0.009940604,
-0.0015569509,
0.0009972322,
0.05185234,
0.021105127,
0.004716563,
0.016403489,
0.011589909,
-0.048031326,
0.010209269,
-0.03835939,
-0.015507939,
-0.058688372,
0.03406075,
0.064658... |
SQA: if you're interested in asking follow-up questions related to a table, in a conversational set-up. For example if you first ask "what's the name of the first actor?" then you can ask a follow-up question such as "how old is he?". Here, questions do not involve any aggregation (all questions are cell selection qu... |
[
0.010935169,
0.020241847,
-0.014842117,
0.0023373836,
-0.049626097,
0.0055961497,
-0.017042007,
0.033226915,
0.008071026,
0.035169676,
0.034712557,
0.022713153,
-0.017327707,
-0.025084464,
-0.035341095,
0.017613407,
-0.017427703,
-0.007542481,
-0.026398685,
0.01370646,
0.0229... | Of course, you don't necessarily have to follow one of these three ways in which TAPAS was fine-tuned. You can also experiment by defining any hyperparameters you want when initializing [TapasConfig], and then create a [TapasForQuestionAnswering] based on that configuration. For example, if you have a dataset that has ... |
[
0.033900015,
0.003953279,
-0.006599872,
-0.03809322,
-0.0143735465,
0.018559372,
-0.0047801086,
0.024583416,
0.010327987,
0.029662512,
0.06402023,
-0.0028108514,
-0.0071904645,
-0.008415944,
-0.0064079296,
0.06839062,
-0.018500313,
0.008164942,
-0.030592695,
-0.020995567,
-0.... | from transformers import TapasConfig, TapasForQuestionAnswering
you can initialize the classification heads any way you want (see docs of TapasConfig)
config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True)
initializing the pre-trained base sized model with our custom classification heads
model = T... |
[
0.027432974,
0.009919229,
-0.016947906,
-0.07449988,
-0.016620673,
-0.02144735,
-0.0077376803,
0.0032535752,
-0.014616376,
0.033023193,
0.053475212,
-0.037222672,
0.013000666,
-0.030596219,
-0.014507298,
0.04453086,
-0.014370952,
-0.004121082,
-0.036759093,
-0.04412182,
0.001... | Initializing a model with a pre-trained base and randomly initialized classification heads from the hub can be done as shown below. Be sure to have installed the tensorflow_probability dependency: |
[
0.028473157,
0.02913911,
-0.02691927,
0.012845479,
-0.055318434,
0.014584354,
-0.025158195,
0.007910033,
-0.0046912637,
0.05380894,
0.019505002,
0.005701291,
-0.0037182332,
-0.04797816,
-0.0073291743,
0.06884466,
-0.017581139,
0.009019953,
-0.032439273,
-0.026253317,
-0.01616... |
from transformers import TapasConfig, TFTapasForQuestionAnswering
for example, the base sized model with default SQA configuration
model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base")
or, the base sized model with WTQ configuration
config = TapasConfig.from_pretrained("google/tapas-base-finetuned-... |
[
0.010487888,
0.022566356,
-0.016544875,
0.011155364,
-0.05172226,
0.002613096,
-0.018731922,
0.028488427,
0.010289066,
0.03286252,
0.026528604,
0.025179453,
-0.01643126,
-0.023461057,
-0.040360972,
0.023091815,
-0.01315069,
-0.0053895107,
-0.021203002,
0.012674936,
0.01368325... | Of course, you don't necessarily have to follow one of these three ways in which TAPAS was fine-tuned. You can also experiment by defining any hyperparameters you want when initializing [TapasConfig], and then create a [TFTapasForQuestionAnswering] based on that configuration. For example, if you have a dataset that ha... |
[
0.027733551,
0.0057267793,
-0.0147376,
-0.030375546,
-0.016737545,
0.013807737,
-0.0041142777,
0.015645325,
0.015866721,
0.02786639,
0.054138727,
-0.0024648765,
-0.0005714787,
-0.0046456284,
-0.014619523,
0.07651449,
-0.017992124,
0.007287622,
-0.024914442,
-0.015778162,
-0.0... | from transformers import TapasConfig, TFTapasForQuestionAnswering
you can initialize the classification heads any way you want (see docs of TapasConfig)
config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True)
initializing the pre-trained base sized model with our custom classification heads
model =... |
[
0.016352512,
0.041652054,
0.012181262,
0.050659537,
-0.045400135,
-0.024664788,
-0.0013422435,
0.0025295764,
0.0054218704,
0.048453007,
-0.02552624,
0.02655394,
0.0012572316,
-0.05325901,
-0.023591748,
0.032765478,
-0.014470915,
-0.015672417,
-0.034488384,
-0.0004538691,
-0.0... |
What you can also do is start from an already fine-tuned checkpoint. A note here is that the already fine-tuned checkpoint on WTQ has some issues due to the L2-loss which is somewhat brittle. See here for more info.
For a list of all pre-trained and fine-tuned TAPAS checkpoints available on HuggingFace's hub, see he... |
[
0.023839269,
0.05532257,
0.009711193,
0.028672557,
-0.04277089,
-0.00017764661,
-0.022679279,
0.04018322,
-0.0030263825,
0.041045777,
-0.024776183,
0.028226407,
-0.0053426432,
-0.078641325,
-0.021385444,
0.027155647,
-0.004513548,
0.003091446,
-0.032985337,
-0.014514739,
0.01... |
The tables themselves should be present in a folder, each table being a separate csv file. Note that the authors of the TAPAS algorithm used conversion scripts with some automated logic to convert the other datasets (WTQ, WikiSQL) into the SQA format. The author explains this here. A conversion of this script that wo... |
[
0.0471783,
0.028887635,
0.016490629,
-0.019335844,
-0.04140077,
-0.014799469,
-0.01862454,
0.025984354,
0.008825971,
0.024242386,
-0.0038577332,
0.00826709,
0.010168738,
-0.04128464,
-0.01617127,
0.0152567355,
-0.03899105,
-0.033329654,
-0.035129685,
-0.018769704,
0.009217913... |
from transformers import TapasTokenizer
import pandas as pd
model_name = "google/tapas-base"
tokenizer = TapasTokenizer.from_pretrained(model_name)
data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
queries = [
"What is the name of the first actor?",
... |
[
0.018382274,
0.021181751,
0.010747989,
0.018667934,
-0.046905506,
-0.027452005,
-0.007180799,
0.04799102,
0.004963357,
0.0037314445,
0.010298072,
0.0036457463,
0.015854176,
-0.017439593,
-0.019667748,
0.003859992,
-0.008277022,
-0.028851744,
-0.045248676,
0.011962047,
-0.0021... | Note that [TapasTokenizer] expects the data of the table to be text-only. You can use .astype(str) on a dataframe to turn it into text-only data.
Of course, this only shows how to encode a single training example. It is advised to create a dataloader to iterate over batches: |
[
0.023422394,
-0.024872696,
-0.018491363,
0.004767871,
-0.013030972,
0.00030184432,
0.017171588,
-0.00016837112,
-0.009492233,
0.025916914,
-0.0073167784,
-0.01589532,
-0.019506576,
0.0028915417,
-0.026627563,
0.0064538484,
-0.021217933,
-0.013371794,
-0.032863867,
0.0022098992,... |
id: optional, id of the table-question pair, for bookkeeping purposes.
annotator: optional, id of the person who annotated the table-question pair, for bookkeeping purposes.
position: integer indicating if the question is the first, second, third, related to the table. Only required in case of conversational setup (S... |
[
0.0042072046,
-0.0027599828,
0.017451584,
0.0054704277,
-0.025476765,
0.03776223,
-0.03855484,
0.011698081,
0.0034959784,
0.06618297,
-0.025844762,
-0.008046412,
0.022575244,
-0.007735029,
-0.00467074,
0.017975273,
-0.02832167,
-0.03110996,
-0.06782481,
0.03235549,
0.01449344... | import torch
import pandas as pd
tsv_path = "your_path_to_the_tsv_file"
table_csv_path = "your_path_to_a_directory_containing_all_csv_files"
class TableDataset(torch.utils.data.Dataset):
def init(self, data, tokenizer):
self.data = data
self.tokenizer = tokenizer |
[
0.014739756,
-0.025929226,
0.008754338,
0.030632596,
0.0075178063,
-0.0113108475,
-0.015748704,
0.008936403,
0.015794221,
0.058352135,
0.0018803999,
-0.0012336865,
-0.029585717,
-0.013837012,
-0.036716633,
-0.007957799,
-0.019799672,
-0.0371718,
-0.03131534,
0.02498855,
0.004... |
def getitem(self, idx):
item = data.iloc[idx]
table = pd.read_csv(table_csv_path + item.table_file).astype(
str
) # be sure to make your table data text only
encoding = self.tokenizer(
table=table,
queries=item.question,
ans... |
[
0.020717744,
0.01855996,
-0.000042291576,
0.0126524605,
-0.040017083,
-0.027990835,
-0.019389877,
0.030042993,
-0.0026142383,
0.039745476,
-0.008917835,
0.030450406,
-0.014810245,
0.008616046,
-0.025983945,
0.0025727425,
-0.012871257,
-0.036184378,
-0.012554379,
-0.011256691,
... |
Third, given that you've prepared your data in this TSV/CSV format (and corresponding CSV files containing the tabular data), you can then use [TapasTokenizer] to convert table-question pairs into input_ids, attention_mask, token_type_ids and so on. Again, based on which of the three cases you picked above, [TapasFor... |
[
0.02443643,
-0.00667103,
-0.0093509685,
0.030401455,
-0.05348351,
-0.004848384,
-0.023125278,
0.0037893755,
-0.009286132,
0.030257372,
-0.021453917,
0.029825123,
0.004019908,
0.000742026,
-0.02567554,
0.01842818,
-0.010460406,
-0.01543126,
-0.01701617,
-0.0017253907,
-0.00349... |
data = pd.read_csv(tsv_path, sep="\t")
train_dataset = TableDataset(data, tokenizer)
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=32)
``
</pt>
<tf>
Third, given that you've prepared your data in this TSV/CSV format (and corresponding CSV files containing the tabular data), you can then use... |
[
0.047703337,
0.027933082,
0.016325656,
-0.019741308,
-0.041798312,
-0.014733615,
-0.01751245,
0.026109472,
0.0073233885,
0.026066052,
-0.0058037126,
0.0092844935,
0.011383093,
-0.042348288,
-0.017150622,
0.015341485,
-0.037716895,
-0.034214407,
-0.034793332,
-0.019205803,
0.0... |
from transformers import TapasTokenizer
import pandas as pd
model_name = "google/tapas-base"
tokenizer = TapasTokenizer.from_pretrained(model_name)
data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
queries = [
"What is the name of the first actor?",
... |
[
0.014518659,
0.03314549,
-0.00653184,
0.02351307,
-0.03180722,
-0.03264753,
-0.022019187,
0.02673425,
-0.005329733,
0.035106212,
-0.015055522,
0.012503475,
0.005072972,
-0.005333623,
-0.027418947,
-0.010153724,
-0.022081433,
-0.036133252,
-0.0265942,
-0.015234477,
-0.00144525... |
| Task | Required inputs |
|------------------------------------|---------------------------------------------------------------------------------------------------------------------|
| Conversati... |
[
0.018382274,
0.021181751,
0.010747989,
0.018667934,
-0.046905506,
-0.027452005,
-0.007180799,
0.04799102,
0.004963357,
0.0037314445,
0.010298072,
0.0036457463,
0.015854176,
-0.017439593,
-0.019667748,
0.003859992,
-0.008277022,
-0.028851744,
-0.045248676,
0.011962047,
-0.0021... | Note that [TapasTokenizer] expects the data of the table to be text-only. You can use .astype(str) on a dataframe to turn it into text-only data.
Of course, this only shows how to encode a single training example. It is advised to create a dataloader to iterate over batches: |
[
0.0013499506,
-0.019349892,
-0.020979205,
-0.0063730646,
0.013892415,
-0.024944348,
-0.021671303,
0.006189226,
-0.015990335,
0.055886872,
-0.044409588,
0.0006781294,
0.010705884,
-0.044294238,
-0.023819689,
-0.046831932,
-0.028938327,
-0.0522822,
-0.032067183,
0.010439137,
-0... |
def iter(self):
for idx in range(self.len()):
item = self.data.iloc[idx]
table = pd.read_csv(table_csv_path + item.table_file).astype(
str
) # be sure to make your table data text only
encoding = self.tokenizer(
table... |
[
0.011093209,
0.03799838,
0.007919778,
0.010748271,
-0.04304827,
0.010768967,
-0.021358566,
0.01292138,
-0.021675909,
0.07710056,
-0.047877405,
-0.0005648361,
0.0261877,
-0.027953781,
-0.0074782576,
0.021758694,
-0.013549168,
-0.05342401,
-0.08344742,
0.022269202,
0.015577404,... | import tensorflow as tf
import pandas as pd
tsv_path = "your_path_to_the_tsv_file"
table_csv_path = "your_path_to_a_directory_containing_all_csv_files"
class TableDataset:
def init(self, data, tokenizer):
self.data = data
self.tokenizer = tokenizer |
[
0.032695454,
0.024449384,
-0.02183548,
0.012282458,
-0.026240123,
-0.020001415,
-0.01855727,
0.03792326,
-0.010744443,
0.022759734,
0.0063578505,
0.03445731,
0.012268016,
-0.018600594,
-0.04705026,
0.006527538,
-0.021344472,
-0.010794988,
-0.048494406,
-0.01359663,
0.01777743... |
Note that here, we encode each table-question pair independently. This is fine as long as your dataset is not conversational. In case your dataset involves conversational questions (such as in SQA), then you should first group together the queries, answer_coordinates and answer_text per table (in the order of their p... |
[
-0.003409095,
0.017869765,
0.010936242,
-0.006577349,
-0.04534605,
-0.0032055671,
-0.024708306,
0.016648596,
-0.0025254441,
0.030556347,
0.03221171,
-0.001967438,
-0.008588884,
-0.003985758,
-0.05622802,
-0.013697439,
-0.016960673,
-0.01875172,
-0.023704235,
0.012469486,
0.01... | You can then fine-tune [TapasForQuestionAnswering] as follows (shown here for the weak supervision for aggregation case): |
[
-0.011676704,
0.01508461,
0.020236097,
0.025889523,
-0.040736374,
-0.04900517,
0.00064765086,
0.0036324586,
-0.01659043,
0.059440233,
-0.011121928,
0.0031288678,
0.02619333,
-0.030539071,
-0.027527433,
-0.000505242,
0.012693792,
-0.026206538,
-0.0673656,
-0.012389987,
0.01003... |
data = pd.read_csv(tsv_path, sep="\t")
train_dataset = TableDataset(data, tokenizer)
output_signature = (
tf.TensorSpec(shape=(512,), dtype=tf.int32),
tf.TensorSpec(shape=(512,), dtype=tf.int32),
tf.TensorSpec(shape=(512,), dtype=tf.float32),
tf.TensorSpec(shape=(512,), dtype=tf.float32),
tf.... |
[
0.01880141,
0.008958161,
-0.032721426,
0.008354693,
-0.020464303,
-0.018600253,
-0.00841504,
0.029583389,
-0.031138998,
0.04235011,
0.004817694,
-0.0010610996,
0.015784066,
-0.013175739,
-0.033606514,
-0.005722897,
0.0008733537,
-0.042779244,
-0.059434988,
0.012994698,
0.0028... |
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = model(
input_ids=input_ids,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
labels=labels,
numeric_values=nu... |
[
0.019429052,
0.049803656,
-0.04696175,
0.03776074,
-0.048818838,
-0.013871865,
-0.023846665,
0.020624904,
-0.014617513,
0.05177329,
-0.010143626,
0.0017876206,
0.02198958,
-0.04628645,
-0.027321666,
0.047524504,
-0.018289478,
-0.020681178,
-0.026998082,
-0.0023952182,
-0.0152... |
import tensorflow as tf
from transformers import TapasConfig, TFTapasForQuestionAnswering
this is the default WTQ configuration
config = TapasConfig(
num_aggregation_labels=4,
use_answer_as_supervision=True,
answer_loss_cutoff=0.664694,
cell_selection_preference=0.207951,
huber_loss_delta=0.1... |
[
0.03465225,
0.043247927,
-0.019722132,
0.017865228,
-0.048549093,
-0.0011802206,
-0.03399335,
0.02057571,
0.0032645597,
0.037737112,
0.008408487,
0.0077420976,
0.009082364,
-0.043607328,
-0.01849418,
0.03084859,
-0.0053011654,
0.0029837776,
-0.018718805,
0.006121049,
-0.00977... |
from transformers import TapasConfig, TapasForQuestionAnswering, AdamW
this is the default WTQ configuration
config = TapasConfig(
num_aggregation_labels=4,
use_answer_as_supervision=True,
answer_loss_cutoff=0.664694,
cell_selection_preference=0.207951,
huber_loss_delta=0.121194,
init_ce... |
[
0.010956432,
-0.0036807794,
-0.030080624,
-0.01437949,
-0.047314867,
-0.0026779817,
-0.018410506,
0.022798365,
0.015555753,
0.06735099,
0.056566376,
-0.047262,
-0.04023085,
-0.019150626,
-0.03187806,
0.011471873,
-0.022864446,
-0.023644216,
-0.017379623,
0.0122516425,
0.02393... | Usage: inference |
[
0.02642573,
0.023298856,
-0.03920956,
0.007104551,
-0.044677954,
-0.013954589,
-0.029901652,
0.043747164,
0.0024724128,
0.059686955,
0.013183778,
0.039151385,
-0.028854514,
-0.020840986,
-0.027443783,
0.01621612,
0.00042858187,
-0.008166234,
0.008478922,
0.020433765,
0.013612... |
Here we explain how you can use [TapasForQuestionAnswering] or [TFTapasForQuestionAnswering] for inference (i.e. making predictions on new data). For inference, only input_ids, attention_mask and token_type_ids (which you can obtain using [TapasTokenizer]) have to be provided to the model to obtain the logits. Next, ... |
[
0.027562503,
0.011316773,
-0.026556881,
0.019560028,
-0.013752923,
-0.040054858,
-0.015679182,
0.020778105,
-0.025367133,
0.04526709,
0.010502362,
0.020466503,
0.039799914,
-0.035919067,
-0.0058956277,
0.009510905,
0.007350945,
-0.05795774,
-0.081526086,
-0.012995168,
0.01494... |
# forward + backward + optimize
with tf.GradientTape() as tape:
outputs = model(
input_ids=input_ids,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
labels=labels,
numeric_values=numeric_... |
[
0.024627242,
-0.00853426,
-0.040795263,
0.0014667194,
-0.046361975,
-0.036893107,
-0.025759686,
0.028734056,
-0.012354553,
0.0657636,
0.050564297,
0.010403475,
-0.0050175446,
-0.031080807,
-0.03923986,
0.008752563,
-0.03449178,
-0.017355042,
-0.023904115,
0.010683174,
0.03091... | However, note that inference is different depending on whether or not the setup is conversational. In a non-conversational set-up, inference can be done in parallel on all table-question pairs of a batch. Here's an example of that: |
[
0.035891335,
0.031248674,
0.005382956,
-0.001762388,
-0.024671573,
-0.008094895,
-0.018109351,
0.030772503,
0.024195403,
0.042022027,
-0.0070830327,
0.002976064,
-0.00972429,
-0.03755793,
-0.01803495,
0.006673824,
-0.035980616,
-0.028004764,
-0.023451386,
0.00602281,
0.023362... |
from transformers import TapasTokenizer, TapasForQuestionAnswering
import pandas as pd
model_name = "google/tapas-base-finetuned-wtq"
model = TapasForQuestionAnswering.from_pretrained(model_name)
tokenizer = TapasTokenizer.from_pretrained(model_name)
data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Cloon... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.