# TAPAS ## Genel Bakış TAPAS modeli, Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno ve Julian Martin Eisenschlos tarafından [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://huggingface.co/papers/2004.02349) makalesinde önerilmiştir. Tabular verilerle ilgili soruları yanıtlamak için özel olarak tasarlanmış (ve ön eğitilmiş) BERT tabanlı bir modeldir. BERT'e kıyasla TAPAS, göreli konum gömme (embedding) kullanır ve tablo yapısını kodlayan 7 token türüne sahiptir. TAPAS, İngilizce Wikipedia'dan gelen milyonlarca tablo ve bunlara karşılık gelen metinlerden oluşan büyük bir veri kümesinde, maskeli dil modelleme (MLM) hedefi üzerinde ön eğitilmiştir. Soru yanıtlama için TAPAS'ın üstünde iki başlık bulunur: bir hücre seçimi başlığı ve (isteğe bağlı olarak) seçilen hücreler arasında toplama işlemlerini (sayma veya toplama gibi) gerçekleştirmek için bir birleştirme başlığı. TAPAS, çeşitli veri kümelerinde ince ayarlanmıştır: - [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253) (Microsoft tarafından sıralı soru yanıtlama) - [WTQ](https://github.com/ppasupat/WikiTableQuestions) (Stanford Üniversitesi tarafından hazırlanan Wiki Tablo Soruları) - [WikiSQL](https://github.com/salesforce/WikiSQL) (Salesforce tarafından). SQA ve WTQ'da en iyi performansı elde ederken, çok daha basit bir mimariye sahip olmasına rağmen WikiSQL'de SOTA ile karşılaştırılabilir bir performans gösterir. Makalenin özeti aşağıdaki gibidir: *Tablolar üzerinde doğal dil sorularını yanıtlamak genellikle bir anlamsal ayrıştırma (semantic parsing) görevi olarak görülür. Tam mantıksal formların toplanma maliyetini azaltmak için popüler bir yaklaşım, mantıksal formlar yerine gösterimlere (denotations) dayalı zayıf denetleme (weak supervision) üzerine odaklanır. Ancak zayıf denetlemeden anlamsal ayrıştırıcılar eğitmek zorluklar doğurur ve ayrıca üretilen mantıksal formlar, gösterimin alınmasından önce yalnızca ara bir adım olarak kullanılır. Bu makalede, mantıksal formlar üretmeden tablolar üzerinde soru yanıtlama için TAPAS adlı bir yaklaşım sunuyoruz. TAPAS zayıf denetlemeden eğitilir ve gösterimi, tablo hücrelerini seçerek ve bu seçime isteğe bağlı olarak ilgili bir toplama (aggregation) operatörü uygulayarak tahmin eder. TAPAS, tabloları girdi olarak kodlamak için BERT mimarisini genişletir, Wikipedia'dan toplanan metin parçaları ve tabloların etkili bir ortak ön-eğitimiyle başlatılır ve uçtan uca (end-to-end) eğitilir. Üç farklı anlamsal ayrıştırma veri seti üzerinde deneyler yapıyoruz ve TAPAS'ın, SQA'da en iyi doğruluğu 55,1'den 67,2'ye yükselterek ve WIKISQL ile WIKITQ'da en iyi performansla (state-of-the-art) eşit düzeyde çalışarak, daha basit bir model mimarisiyle anlamsal ayrıştırma modellerini geride bıraktığını veya onlarla yarıştığını görüyoruz. Ayrıca, bizim ortamımızda basit olan WIKISQL'den WIKITQ'ya aktarım öğrenmesinin (transfer learning), en iyi performansın 4,2 puan üzerinde, 48,7 doğruluk sağladığını buluyoruz.* Ayrıca yazarlar, TAPAS'ı **tablo çıkarımı** (table entailment) tanıması için, ince ayar (fine-tuning) öncesinde ara bir adımda öğrenilen, otomatik olarak oluşturulan milyonlarca eğitim örneğinden oluşan dengeli bir veri seti oluşturarak daha fazla ön eğitimden geçirmiştir. TAPAS yazarları bu ek ön eğitime ara ön eğitim (intermediate pre-training) adını vermektedir (TAPAS önce MLM üzerinde, ardından başka bir veri seti üzerinde ön eğitildiği için). Araştırmacılar, ara ön eğitimin SQA üzerindeki performansı daha da artırdığını ve [TabFact](https://github.com/wenhuchen/Table-Fact-Checking) üzerinde de yeni bir en iyi performansa (state-of-the-art) ulaştığını tespit etmiştir. Tablo çıkarımı (ikili sınıflandırma görevi) için 16k Wikipedia tablosu içeren büyük ölçekli bir veri seti olan TabFact'ta da en iyi performansa ulaşmıştır. Daha fazla ayrıntı için Julian Martin Eisenschlos, Syrine Krichene ve Thomas Müller'in takip makalesine bakınız: [Understanding tables with intermediate pre-training](https://www.aclweb.org/anthology/2020.findings-emnlp.27/). drawing TAPAS mimarisi. Orijinal blog gönderisinden alınmıştır. Bu model [nielsr](https://huggingface.co/nielsr) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/google-research/tapas) bulunabilir. ## Kullanım ipuçları - TAPAS, varsayılan olarak göreli konum gömme kullanır (konum gömme her tablo hücresinde yeniden başlatılır). Dikkat edin, bu özellik orijinal TAPAS makalesinin yayımlanmasından sonra eklenmiştir. Yazarlara göre bu, genellikle biraz daha iyi bir performans sağlar ve gömme havuzunun dolması olmadan daha uzun dizilerin kodlanmasına olanak tanır. Bu durum, [TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)'in `reset_position_index_per_cell` parametresinde yansıtılır ve bu parametre varsayılan olarak `True` olarak ayarlanmıştır. [hub](https://huggingface.co/models?search=tapas)'da mevcut olan varsayılan model sürümlerinin tümü göreli konum gömme kullanır. `from_pretrained()` metodunu çağırırken `revision="no_reset"` ek argümanını geçirerek mutlak konum gömme kullanan sürümleri kullanmaya devam edebilirsiniz. Dikkat edin, girdilerin soldan değil sağdan doldurulması (padding) genellikle önerilir. - TAPAS, BERT tabanlıdır; bu nedenle örneğin `TAPAS-base`, `BERT-base` mimarisine karşılık gelir. Elbette `TAPAS-large` en iyi performansı sağlayacaktır (makalede raporlanan sonuçlar `TAPAS-large` modeline aittir). Farklı boyutlardaki modellerin sonuçları [orijinal GitHub deposunda](https://github.com/google-research/tapas) gösterilmektedir. - TAPAS, SQA üzerinde ince ayar yapılmış kontrol noktalarına sahiptir ve bu kontrol noktaları, sohbet ortamında bir tabloyla ilgili soruları yanıtlama yeteneğine sahiptir. Bu, önceki soruyla ilgili "yaşı kaç?" gibi takip soruları sorabileceğiniz anlamına gelir. Not: Sohbet ortamında TAPAS'ın ileri geçişi biraz farklıdır: bu durumda, modelin önceki soruya verdiği tahmini `labels` ile `prev_labels` token tipi kimliklerinin üzerine yazılabilmesi için her tablo-soru çiftini modele tek tek girmeniz gerekir. Daha fazla bilgi için "Kullanım" bölümüne bakın. - TAPAS, BERT ile benzerlik gösterir ve bu nedenle maskeli dil modelleme (MLM) hedefine dayanır. Bu sayede maskeli token tahmininde ve genel olarak NLU'da verimlidir, ancak metin üretimi için en uygun seçenek değildir. Bu açıdan, nedensel dil modelleme (CLM) hedefiyle eğitilen modeller daha iyidir. TAPAS'ın, GPT-2 gibi otoregresif bir metin çözücüyle birleştirilebilmesi için EncoderDecoderModel çerçevesinde bir kodlayıcı olarak kullanılabileceğini unutmayın. ## Kullanım: ince ayar Burada, kendi veri setinizde [TapasForQuestionAnswering](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForQuestionAnswering) modelini nasıl ince ayarlayabileceğinizi açıklıyoruz. **ADIM 1: TAPAS'ı kullanabileceğiniz 3 yoldan birini seçin - ya da deneyin** Temel olarak, [TapasForQuestionAnswering](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForQuestionAnswering) için ince ayar yapılabilen 3 farklı yöntem bulunmaktadır; bunlar, Tapas'ın ince ayarının yapıldığı farklı veri setlerine karşılık gelmektedir: 1. SQA: Bir tabloya ilişkin, sohbet ortamında takip soruları sormakla ilgileniyorsanız. Örneğin önce "ilk aktörün adı nedir?" diye sorduysanız, ardından "kaç yaşında?" gibi bir takip sorusu sorabilirsiniz. Burada sorular herhangi bir birleştirme (aggregation) içermez (tüm sorular hücre seçimi sorularıdır). 2. WTQ: Konuşma ortamında soru sormakla ilgilenmiyorsanız, bunun yerine bir tabloyla ilgili, satır sayısını sayma, hücre değerlerini toplama veya hücre değerlerinin ortalamasını alma gibi birleştirmeler (aggregation) içerebilecek sorular sormak istiyorsanız. Bu durumda örneğin "Cristiano Ronaldo'nun kariyerindeki toplam gol sayısı nedir?" diye sorabilirsiniz. Bu durum, modelin yalnızca sorunun cevabı denetim (supervision) olarak verildiğinde uygun birleştirme operatörünü (SUM/COUNT/AVERAGE/NONE) kendisinin öğrenmesi gerektiği için **zayıf denetim** olarak da adlandırılır. 3. WikiSQL-supervised: bu veri seti, eğitim sırasında modele doğru birleşim operatörünün verilmesiyle WikiSQL üzerine kuruludur. Buna **güçlü denetim** de denir. Burada, uygun birleşim operatörünü öğrenmek çok daha kolaydır. Özetlemek gerekirse: | **Görev** | **Örnek veri seti** | **Açıklama** | |-------------------------------------|---------------------|---------------------------------------------------------------------------------------------------------| | Sohbet | SQA | Sohbet tarzı, yalnızca hücre seçimi soruları | | Toplama için zayıf denetim | WTQ | Sorular birleştirme (aggregation) içerebilir ve model, yalnızca cevabın denetim sinyali olarak verildiği durumda bunu öğrenmek zorundadır. | | Toplama için güçlü denetim | WikiSQL-gözetimli | Sorular birleştirme (aggregation) içerebilir ve model, altın (gold) birleştirme operatörü verildiğinde bunu öğrenmelidir. | Hub'dan önceden eğitilmiş bir taban ve rastgele başlatılmış sınıflandırma başlıklarıyla bir model başlatmak aşağıda gösterildiği gibi yapılabilir. ```python from transformers import TapasConfig, TapasForQuestionAnswering # for example, the base sized model with default SQA configuration model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", device_map="auto") # or, the base sized model with WTQ configuration config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq") model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") # or, the base sized model with WikiSQL configuration config = TapasConfig("google-base-finetuned-wikisql-supervised") model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") ``` Elbette, TAPAS'ın ince ayarının yapıldığı bu üç yoldan birini takip etmek zorunda değilsiniz. [TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)'i başlatırken istediğiniz hiperparametreleri tanımlayarak deneyler yapabilir ve ardından bu yapılandırmaya dayalı bir [TapasForQuestionAnswering](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForQuestionAnswering) oluşturabilirsiniz. Örneğin, hem konuşma tarzı soruları hem de toplama (aggregation) içerebilecek soruları olan bir veri setiniz varsa, bunu şu şekilde yapabilirsiniz. İşte bir örnek: ```python 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 = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") ``` Yapabileceğiniz bir diğer şey de, zaten ince ayarı yapılmış bir kontrol noktasından başlamaktır. Burada dikkat edilmesi gereken nokta, WTQ üzerinde ince ayarı yapılmış kontrol noktasının, biraz kırılgan olan L2-kaybı nedeniyle bazı sorunlara sahip olmasıdır. Daha fazla bilgi için [buraya](https://github.com/google-research/tapas/issues/91#issuecomment-735719340) bakın. HuggingFace'in hub'ında kullanılabilir tüm önceden eğitilmiş ve ince ayarlanmış TAPAS kontrol noktalarının listesi için [buraya](https://huggingface.co/models?search=tapas) bakın. **ADIM 2: Verilerinizi SQA biçiminde hazırlayın** İkincisi, yukarıda ne seçtiyseniz seçin, veri setinizi [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253) biçiminde hazırlamalısınız. Bu biçim, aşağıdaki sütunlara sahip bir TSV/CSV dosyasıdır: - `id`: isteğe bağlı, tablo-soru çiftinin id'si, kayıt tutma amaçlıdır. - `annotator`: isteğe bağlı, tablo-soru çiftini etiketleyen kişinin kimliği, kayıt tutma amaçlıdır. - `position`: sorunun tabloya ilişkin olarak birinci, ikinci, üçüncü vb. olduğunu gösteren tamsay. Yalnızca konuşma tabanlı kurulumda (SQA) gereklidir. WTQ/WikiSQL denetimli yaklaşım kullanıyorsanız bu sütuna ihtiyacınız yoktur. - `question`: string - `table_file`: string, tabular verileri içeren csv dosyasının adı - `answer_coordinates`: bir veya daha fazla demet listesi (her demet, cevabın bir parçası olan bir hücre koordinatı, yani satır-sütun çiftidir) - `answer_text`: bir veya daha fazla dizeden oluşan liste (her dize, cevabın bir parçası olan bir hücre değeridir) - `aggregation_label`: toplama operatörünün indeksi. Yalnızca toplama için güçlü denetim durumunda (WikiSQL-denetimli durum) gereklidir - `float_answer`: soruya ait ondalıklı sayı cevabı, eğer varsa (yoksa np.nan). Yalnızca toplanma için zayıf denetim durumunda (WTQ ve WikiSQL gibi) zorunludur Tabloların kendisi bir klasörde bulunmalıdır ve her tablo ayrı bir csv dosyası olmalıdır. TAPAS algoritmasının yazarları, diğer veri setlerini (WTQ, WikiSQL) SQA formatına dönüştürmek için bazı otomatik mantık içeren dönüştürme betikleri kullanmıştır. Yazar bunu [burada](https://github.com/google-research/tapas/issues/50#issuecomment-705465960) açıklıyor. HuggingFace'in uygulamasıyla çalışan bu betiğin bir dönüştürmesi [burada](https://github.com/NielsRogge/tapas_utils) bulunabilir. İlginç bir şekilde, bu dönüştürme betikleri mükemmel değildir (`answer_coordinates` ve `float_answer` alanları `answer_text` temel alınarak doldurulmaktadır), bu da WTQ ve WikiSQL sonuçlarının aslında iyileştirilebileceği anlamına gelir. **3. ADIM: Verilerinizi TapasTokenizer kullanarak tensörlere dönüştürün** Üçüncüsü, verilerinizi bu TSV/CSV biçiminde (ve tabular verileri içeren ilgili CSV dosyalarıyla) hazırladığınızı varsayarsak, ardından [TapasTokenizer](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasTokenizer)'ı kullanarak tablo-soru çiftlerini `input_ids`, `attention_mask`, `token_type_ids` vb. değerlere dönüştürebilirsiniz. Yine, yukarıdaki üç durumdan hangisini seçtiğinize bağlı olarak, [TapasForQuestionAnswering](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForQuestionAnswering)'in ince ayar için farklı girdilere ihtiyacı vardır: | **Görev** | **Zorunlu girdiler** | |------------------------------------|---------------------------------------------------------------------------------------------------------------------| | Sohbet | `input_ids`, `attention_mask`, `token_type_ids`, `labels` | | Toplama için zayıf denetim | `input_ids`, `attention_mask`, `token_type_ids`, `labels`, `numeric_values`, `numeric_values_scale`, `float_answer` | | Toplama için güçlü denetim | `input ids`, `attention mask`, `token type ids`, `labels`, `aggregation_labels` | [TapasTokenizer](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasTokenizer), TSV dosyasındaki `answer_coordinates` ve `answer_text` sütunlarına dayanarak `labels`, `numeric_values` ve `numeric_values_scale` değerlerini oluşturur. `float_answer` ve `aggregation_labels` değerleri zaten 2. adımın TSV dosyasında mevcuttur. İşte bir örnek: ```py 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?", "How many movies has George Clooney played in?", "What is the total number of movies?", ] answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]] answer_text = [["Brad Pitt"], ["69"], ["209"]] table = pd.DataFrame.from_dict(data) inputs = tokenizer( table=table, queries=queries, answer_coordinates=answer_coordinates, answer_text=answer_text, padding="max_length", return_tensors="pt", ) inputs {'input_ids': tensor([[ ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]), 'numeric_values': tensor([[ ]]), 'numeric_values_scale: tensor([[ ]]), labels: tensor([[ ]])} ``` [TapasTokenizer](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasTokenizer)'in tablo verisinin **sadece metin** olmasını beklediğini unutmayın. Bir dataframe'i sadece metin verisine dönüştürmek için `.astype(str)` kullanabilirsiniz. Elbette bu, yalnızca tek bir eğitim örneğinin nasıl kodlanacağını göstermektedir. Batch'ler üzerinde döngü yapmak için bir dataloader oluşturmanız önerilir: ```python import pandas as pd import torch 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 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, answer_coordinates=item.answer_coordinates, answer_text=item.answer_text, truncation=True, padding="max_length", return_tensors="pt", ) # remove the batch dimension which the tokenizer adds by default encoding = {key: val.squeeze(0) for key, val in encoding.items()} # add the float_answer which is also required (weak supervision for aggregation case) encoding["float_answer"] = torch.tensor(item.float_answer) return encoding def __len__(self): return len(self.data) data = pd.read_csv(tsv_path, sep="\t") train_dataset = TableDataset(data, tokenizer) train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=32) ``` Burada her tablo-soru çiftinin bağımsız olarak kodlandığına dikkat edin. Veri setiniz **sohbet tabanlı değilse** bu uygundur. Veri setiniz sohbet tabanlı soruları içeriyorsa (SQA'daki gibi), önce `queries`, `answer_coordinates` ve `answer_text` alanlarını tablo bazında (`position` dizin sırasına göre) gruplayıp her tabloyu sorularıyla birlikte toplu olarak kodlamalısınız. Bu, `prev_labels` token türlerinin ([TapasTokenizer](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasTokenizer) belgelerine bakın) doğru şekilde ayarlanmasını sağlar. Daha fazla bilgi için [bu defterine](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb) bakın. **ADIM 4: Modeli eğitin (ince ayarlayın) Ardından [TapasForQuestionAnswering](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForQuestionAnswering) modelini aşağıdaki gibi ince ayarlayabilirsiniz (burada toplama için zayıf denetim durumu gösterilmektedir): ```python from transformers import AdamW, TapasConfig, TapasForQuestionAnswering # 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_cell_selection_weights_to_zero=True, select_one_column=True, allow_empty_column_selection=False, temperature=0.0352513, ) model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") optimizer = AdamW(model.parameters(), lr=5e-5) model.train() for epoch in range(2): # loop over the dataset multiple times for batch in train_dataloader: # get the inputs; input_ids = batch["input_ids"] attention_mask = batch["attention_mask"] token_type_ids = batch["token_type_ids"] labels = batch["labels"] numeric_values = batch["numeric_values"] numeric_values_scale = batch["numeric_values_scale"] float_answer = batch["float_answer"] # 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=numeric_values, numeric_values_scale=numeric_values_scale, float_answer=float_answer, ) loss = outputs.loss loss.backward() optimizer.step() ``` ## Kullanım: inference Burada, [TapasForQuestionAnswering](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForQuestionAnswering)'i çıkarım (yani yeni veriler üzerinde tahmin yapma) için nasıl kullanabileceğinizi açıklıyoruz. Çıkarım için, logitleri elde etmek üzere modele yalnızca `input_ids`, `attention_mask` ve `token_type_ids` ([TapasTokenizer](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasTokenizer) kullanarak elde edilebilir) sağlanmalıdır. Ardından, bu değerleri tahmin edilen koordinatlara ve isteğe bağlı toplama indekslerine dönüştürmek için kullanışlı `~models.tapas.tokenization_tapas.convert_logits_to_predictions` yöntemini kullanabilirsiniz. Ancak, kurulumun sohbet tabanlı olup olmadığına bağlı olarak çıkarımın **farklı** olduğunu unutmayın. Sohbet dışı bir kurulumda, bir partideki tüm tablo-soru çiftleri üzerinde çıkarım paralel olarak yapılabilir. Bunun bir örneği aşağıdadır: ```py from transformers import TapasTokenizer, TapasForQuestionAnswering import pandas as pd model_name = "google/tapas-base-finetuned-wtq" model = TapasForQuestionAnswering.from_pretrained(model_name, device_map="auto") 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?", "How many movies has George Clooney played in?", "What is the total number of movies?", ] table = pd.DataFrame.from_dict(data) inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt").to(model.device) outputs = model(**inputs) predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions( inputs, outputs.logits.detach(), outputs.logits_aggregation.detach() ) # let's print out the results: id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"} aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices] answers = [] for coordinates in predicted_answer_coordinates: if len(coordinates) == 1: # only a single cell: answers.append(table.iat[coordinates[0]]) else: # multiple cells cell_values = [] for coordinate in coordinates: cell_values.append(table.iat[coordinate]) answers.append(", ".join(cell_values)) display(table) print("") for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string): print(query) if predicted_agg == "NONE": print("Predicted answer: " + answer) else: print("Predicted answer: " + predicted_agg + " > " + answer) What is the name of the first actor? Predicted answer: Brad Pitt How many movies has George Clooney played in? Predicted answer: COUNT > 69 What is the total number of movies? Predicted answer: SUM > 87, 53, 69 ``` Sohbet tabanlı bir kurulumda, her tablo-soru çifti modele **ardışık olarak** sağlanmalıdır; böylece `prev_labels` token türleri, önceki tablo-soru çiftinin tahmin edilen `labels` değerleriyle üzerine yazılabilir. Yine, daha fazla bilgi [bu notebook](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb)'ta bulunabilir. ## Kaynaklar - [Metin sınıflandırma görevi kılavuzu](../tasks/sequence_classification) - [Masked dil modelleme görevi kılavuzu](../tasks/masked_language_modeling) ## TAPAS'a özgü çıktılar[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] #### transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] ```python transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_aggregation: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L49) **Parametreler:** loss (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` (ve olası olarak `answer`, `aggregation_labels`, `numeric_values` ve `numeric_values_scale`) sağlandığında döndürülür) : Hiyerarşik hücre seçimi log-olabilirlik kaybının ve (isteğe bağlı olarak) yarı denetimli regresyon kaybının ve (isteğe bağlı olarak) agregasyonlar için denetimli kaybın toplamı olarak toplam kayıp. logits (`torch.Tensor`, şekli `(batch_size, sequence_length)`) : Her token için hücre seçimi başlığının tahmin puanları. logits_aggregation (`torch.Tensor`, *isteğe bağlı*, şekli `(batch_size, num_aggregation_labels)`) : Her birleştirme operatörü için birleştirme başlığının tahmin puanları. hidden_states (`tuple[torch.Tensor]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) : `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Modelin her katmanının çıktısındaki gizli durumlar ve isteğe bağlı başlangıç gömme çıktıları. attentions (`tuple[torch.Tensor]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) : `torch.Tensor` (her katman için bir tane) içeren bir Tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`. Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır. [TapasForQuestionAnswering](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForQuestionAnswering) için çıktı türü. ## TapasConfig[[transformers.TapasConfig]] #### transformers.TapasConfig[[transformers.TapasConfig]] ```python transformers.TapasConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 1024, type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10), initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, positive_label_weight: float = 10.0, num_aggregation_labels: int = 0, aggregation_loss_weight: float = 1.0, use_answer_as_supervision: bool | None = None, answer_loss_importance: float = 1.0, use_normalized_answer_loss: bool = False, huber_loss_delta: float | None = None, temperature: float = 1.0, aggregation_temperature: float = 1.0, use_gumbel_for_cells: bool = False, use_gumbel_for_aggregation: bool = False, average_approximation_function: str = 'ratio', cell_selection_preference: float | None = None, answer_loss_cutoff: float | int | None = None, max_num_rows: int = 64, max_num_columns: int = 32, average_logits_per_cell: bool = False, select_one_column: bool = True, allow_empty_column_selection: bool = False, init_cell_selection_weights_to_zero: bool = False, reset_position_index_per_cell: bool = True, disable_per_token_loss: bool = False, aggregation_labels: dict | None = None, no_aggregation_label_index: int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, tie_word_embeddings: bool = True) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/configuration_tapas.py#L32) **Parametreler:** vocab_size (`int`, *isteğe bağlı*, varsayılan `30522`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar. hidden_size (`int`, *isteğe bağlı*, varsayılan `768`) : Gizli temsillerin boyutu. num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer decoder'ındaki gizli katman sayısı. num_attention_heads (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı. intermediate_size (`int`, *isteğe bağlı*, varsayılan `3072`) : MLP temsil boyutu. hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb. hidden_dropout_prob (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Gömme, kodlayıcı ve havuzlayıcıdaki tüm tam bağlı katmanlar için dropout olasılığı. attention_probs_dropout_prob (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Dikkat olasılıkları için dropout oranı. max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `1024`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu. type_vocab_sizes (`list[int]`, *isteğe bağlı*, varsayılan `[3, 256, 256, 2, 256, 256, 10]`) : [TapasModel](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasModel) çağrılırken geçirilen `token_type_ids` için sözlük boyutları. initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması. layer_norm_eps (`float`, *opsiyonel*, varsayılan `1e-12`) : Katman normalizasyonu katmanları tarafından kullanılan epsilon. pad_token_id (`int`, *isteğe bağlı*, varsayılan `0`) : Sözlükte dolgu için kullanılan token kimliği. bos_token_id (`int`, *isteğe bağlı*) : Sözlükte akış başlangıcı için kullanılan token kimliği. eos_token_id (`Union[int, list[int]]`, *isteğe bağlı*) : Sözlükte akış sonu için kullanılan token kimliği. positive_label_weight (`float`, *isteğe bağlı*, varsayılan 10.0) : Pozitif etiketler için ağırlık. num_aggregation_labels (`int`, *isteğe bağlı*, varsayılan 0) : Tahmin edilecek birleştirme operatörlerinin sayısı. aggregation_loss_weight (`float`, *isteğe bağlı*, varsayılan 1.0) : Toplama kaybı için önem ağırlığı. use_answer_as_supervision (`bool`, *isteğe bağlı*) : Toplama örnekleri için gözetim olarak yalnızca cevabın kullanılıp kullanılmayacağı. answer_loss_importance (`float`, *isteğe bağlı*, varsayılan 1.0) : Regresyon kaybı için önem ağırlığı. use_normalized_answer_loss (`bool`, *isteğe bağlı*, varsayılan `False`) : Cevap kaybının, tahmin edilen ve beklenen değerin maksimumuna bölünerek normalize edilip edilmeyeceğini belirtir. huber_loss_delta (`float`, *isteğe bağlı*) : Regresyon kaybını hesaplamak için kullanılan Delta parametresi. temperature (`float`, *opsiyonel*, varsayılan 1.0) : Hücre logit olasılıklarının çarpıklığını kontrol etmek (veya değiştirmek) için kullanılan değer. aggregation_temperature (`float`, *opsiyonel*, varsayılan 1.0) : Olasılıkların çarpıklığını kontrol etmek için birleştirme logitlerini ölçekler. use_gumbel_for_cells (`bool`, *isteğe bağlı*, varsayılan `False`) : Hücre seçimine Gumbel-Softmax uygulanıp uygulanmayacağı. use_gumbel_for_aggregation (`bool`, *isteğe bağlı*, varsayılan `False`) : Toplama seçiminde Gumbel-Softmax uygulanıp uygulanmayacağı. average_approximation_function (`string`, *isteğe bağlı*, varsayılan `"ratio"`) : Zayıf denetim durumunda hücrelerin beklenen ortalamasını hesaplamak için kullanılan yöntem. `"ratio"`, `"first_order"` veya `"second_order"` değerlerinden biri. cell_selection_preference (`float`, *opsiyonel*) : Belirsiz durumlarda hücre seçimi tercihi. Yalnızca agregasyon için zayıf denetim durumunda geçerlidir (WTQ, WikiSQL). Agregasyon olasılıklarının toplam kütlesi ("NONE" operatörü hariç) bu hiperparametreden yüksekse, bir örnek için agregasyon tahmin edilir. answer_loss_cutoff (`float`, *isteğe bağlı*) : Cevap kaybı kesme değerinden büyük olan örnekleri yoksayın. max_num_rows (`int`, *isteğe bağlı*, varsayılan 64) : Satır sayısının üst sınırı. max_num_columns (`int`, *isteğe bağlı*, varsayılan 32) : Maksimum sütun sayısı. average_logits_per_cell (`bool`, *isteğe bağlı*, varsayılan `False`) : Logitlerin hücre başına ortalama alınacak olup olmadığı. select_one_column (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin yalnızca tek bir sütundan hücre seçmesine kısıtlama getirilip getirilmeyeceğini belirtir. allow_empty_column_selection (`bool`, *isteğe bağlı*, varsayılan `False`) : Hiçbir sütun seçilmemesine izin verilip verilmeyeceği. init_cell_selection_weights_to_zero (`bool`, *isteğe bağlı*, varsayılan `False`) : Hücre seçim ağırlıklarının başlangıç olasılıklarının %50 olması için 0 olarak başlatılıp başlatılmayacağını belirtir. reset_position_index_per_cell (`bool`, *isteğe bağlı*, varsayılan `True`) : Her hücrede konum indekslerinin yeniden başlatılıp başlatılmayacağını (yani göreli konum gömme kullanılıp kullanılmayacağını) belirtir. disable_per_token_loss (`bool`, *isteğe bağlı*, varsayılan `False`) : Hücrelerdeki herhangi bir (güçlü veya zayıf) denetimin devre dışı bırakılıp bırakılmayacağı. aggregation_labels (`dict[int, label]`, *isteğe bağlı*) : Sonuçları birleştirmek için kullanılan birleştirme etiketleri. Örneğin, WTQ modellerinin aşağıdaki birleştirme etiketleri vardır: `{0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}` no_aggregation_label_index (`int`, *isteğe bağlı*) : Toplama etiketleri tanımlıysa ve bu etiketlerden biri "No aggregation"ı temsil ediyorsa, bu değer ilgili etiketin indeksine ayarlanmalıdır. Örneğin, WTQ modellerinde "NONE" toplama etiketi 0. indekste yer alır, bu nedenle bu modeller için bu değer 0 olarak ayarlanmalıdır. is_decoder (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelin bir çözücü olarak kullanılıp kullanılmadığı. `False` ise model, bir kodlayıcı olarak kullanılır. add_cross_attention (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelde çapraz dikkat katmanlarının eklenip eklenmeyeceğini belirtir. tie_word_embeddings (`bool`, *isteğe bağlı*, varsayılan `True`) : Ağırlık gömme bağlamalarının, modelin `tied_weights_keys` eşlemesine göre yapılıp yapılmayacağını belirtir. Bu, bir TapasModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Tapas modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [google/tapas-base-finetuned-sqa](https://huggingface.co/google/tapas-base-finetuned-sqa) modelinin yapılandırmasına benzer bir yapılandırma üretir. Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun. Örnek: ```python >>> from transformers import TapasModel, TapasConfig >>> # Initializing a default (SQA) Tapas configuration >>> configuration = TapasConfig() >>> # Initializing a model from the configuration >>> model = TapasModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## TapasTokenizer[[transformers.TapasTokenizer]] #### transformers.TapasTokenizer[[transformers.TapasTokenizer]] ```python transformers.TapasTokenizer(vocab_file, do_lower_case = True, do_basic_tokenize = True, never_split = None, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', empty_token = '[EMPTY]', tokenize_chinese_chars = True, strip_accents = None, cell_trim_length: int = -1, max_column_id: int | None = None, max_row_id: int | None = None, strip_column_names: bool = False, update_answer_coordinates: bool = False, min_question_length = None, max_question_length = None, model_max_length: int = 512, additional_special_tokens: list[str] | None = None, clean_up_tokenization_spaces = True, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L149) **Parametreler:** vocab_file (`str`) : Sözlüğü içeren dosya. do_lower_case (`bool`, *isteğe bağlı*, varsayılan `True`) : Tokenize sırasında girdinin küçük harfe dönüştürülüp dönüştürülmemesi. do_basic_tokenize (`bool`, *isteğe bağlı*, varsayılan `True`) : WordPiece'ten önce temel tokenizasyonun yapılıp yapılmayacağı. never_split (`Iterable`, *isteğe bağlı*) : Tokenizasyon sırasında asla bölünmeyecek token koleksiyonu. Yalnızca `do_basic_tokenize=True` olduğunda etkilidir. unk_token (`str`, *isteğe bağlı*, varsayılan `"[UNK]"`) : Bilinmeyen jeton. Sözlükte yer almayan bir jeton, bir kimliğe dönüştürülemez ve bunun yerine bu jeton olarak ayarlanır. sep_token (`str`, *isteğe bağlı*, varsayılan `"[SEP]"`) : Birden fazla diziden bir dizi oluşturulurken kullanılan ayraç belirteci, örneğin dizi sınıflandırması için iki dizi veya soru cevaplamada bir metin ve bir soru. Özel belirteçlerle oluşturulan bir dizinin son belirteci olarak da kullanılır. pad_token (`str`, *isteğe bağlı*, varsayılan `"[PAD]"`) : Dolgu için kullanılan jeton, örneğin farklı uzunluklardaki dizileri toplu işleme (batching) sırasında. cls_token (`str`, *isteğe bağlı*, varsayılan `"[CLS]"`) : Sıralı sınıflandırma (token başına sınıflandırma yerine tüm sıranın sınıflandırılması) yapılırken kullanılan sınıflandırıcı tokenı. Özel tokenlarla oluşturulduğunda sıranın ilk tokenıdır. mask_token (`str`, *isteğe bağlı*, varsayılan `"[MASK]"`) : Değerleri maskelemek için kullanılan belirteç. Bu, modelin maskeli dil modelleme ile eğitildiğinde kullanılan belirteçtir. Modelin tahmin etmeye çalışacağı belirteç budur. empty_token (`str`, *isteğe bağlı*, varsayılan `"[EMPTY]"`) : Bir tablodaki boş hücre değerleri için kullanılan belirteç. Boş hücre değerleri "", "n/a", "nan" ve "?" değerlerini içerir. tokenize_chinese_chars (`bool`, *isteğe bağlı*, varsayılan `True`) : Çin karakterlerinin tokenize edilip edilmeyeceğini belirtir. Japonca için bu muhtemelen devre dışı bırakılmalıdır (bkz. bu [konu](https://github.com/huggingface/transformers/issues/328)). strip_accents (`bool`, *isteğe bağlı*) : Tüm aksanların kaldırılıp kaldırılmayacağını belirtir. Bu seçenek belirtilmezse, `lowercase` değeri tarafından (orijinal BERT'te olduğu gibi) belirlenir. cell_trim_length (`int`, *isteğe bağlı*, varsayılan -1) : > 0 ise: Hücreleri uzunluk bu değere eşit veya daha küçük olacak şekilde kırpın. Ayrıca daha fazla hücre kırpma işlemini devre dışı bırakır, bu nedenle `truncation`'ın `True` olarak ayarlanmasıyla kullanılmalıdır. max_column_id (`int`, *isteğe bağlı*) : Çıkarılacak en büyük sütun kimliği. max_row_id (`int`, *isteğe bağlı*) : Çıkarılacak en büyük satır kimliği. strip_column_names (`bool`, *isteğe bağlı*, varsayılan `False`) : Sütun adları yerine boş dizgiler eklenip eklenmeyeceğini belirtir. update_answer_coordinates (`bool`, *isteğe bağlı*, varsayılan `False`) : Cevap koordinatlarının cevap metninden yeniden hesaplanıp hesaplanmayacağı. min_question_length (`int`, *isteğe bağlı*) : Her sorunun token cinsinden minimum uzunluğu (aksi halde atlanır). max_question_length (`int`, *isteğe bağlı*) : Her sorunun token cinsinden maksimum uzunluğu (aksi halde atlanır). clean_up_tokenization_spaces (`bool`, *isteğe bağlı*, varsayılan `True`) : Çözümleme sonrası boşlukların temizlenip temizlenmeyeceğini belirtir. Temizleme işlemi, ek boşluklar gibi olası artefaktların kaldırılmasını içerir. TAPAS tokenizer'ı oluşturur. WordPiece tabanlıdır. TAPAS modelleri tarafından kullanılacak şekilde bir tabloyu ve bir veya daha fazla ilgili cümleyi düzleştirir. Bu tokenizer, ana yöntemlerin çoğunu içeren [PreTrainedTokenizer](/docs/transformers/main/tr/main_classes/tokenizer#transformers.PythonBackend) sınıfından devralır. Kullanıcıların bu yöntemler hakkında daha fazla bilgi için bu üst sınıfa başvurması gerekir. [TapasTokenizer](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasTokenizer), tablo yapısını kodlamak için birkaç token türü kimliği oluşturur. Daha da spesifik olmak gerekirse, aşağıdaki sırayla 7 token türü kimliği ekler: `segment_ids`, `column_ids`, `row_ids`, `prev_labels`, `column_ranks`, `inv_column_ranks` ve `numeric_relations`: - segment_ids: bir token'ın soruya (0) mı yoksa tabloya (1) mı ait olduğunu belirtir. Özel token'lar ve dolgu için 0. - column_ids: bir token'ın tablonun hangi sütununa ait olduğunu belirtir (1'den başlar). Tüm soru token'ları, özel token'lar ve dolgu için 0'dır. - row_ids: bir token'ın tablonun hangi satırına ait olduğunu belirtir (1'den başlar). Tüm soru token'ları, özel token'lar ve dolgu için 0'dır. Sütun başlıklarının token'ları da 0'dır. - prev_labels: bir token'ın önceki sorunun cevabının (bir parçası) olup olmadığını (1) veya olmadığını (0) belirtir. Konuşma tabanlı kurulumlarda (SQA gibi) faydalıdır. - column_ranks: uygunsa, bir tablo jetonunun bir sütuna göre sırasını belirtir. Örneğin, 87, 53 ve 69 değerlerine sahip bir "number of movies" sütununuz varsa, bu jetonların sütun sıraları sırasıyla 3, 1 ve 2'dir. Tüm soru jetonları, özel jetonlar ve dolgu için 0. - inv_column_ranks: uygunsa, bir tablo jetonunun bir sütuna göre ters sırasını belirtir. Örneğin, 87, 53 ve 69 değerlerine sahip bir "number of movies" sütununuz varsa, bu jetonların ters sütun sırası sırasıyla 1, 3 ve 2'dir. Tüm soru jetonları, özel jetonlar ve dolgu için 0. - numeric_relations: soru ile tablo belirteçleri arasındaki sayısal ilişkileri belirtir. Tüm soru belirteçleri, özel belirteçler ve dolgu için 0. [TapasTokenizer](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasTokenizer), bir tablo ve ilişkili cümleler üzerinde uçtan uca tokenizasyon çalıştırır: noktalama ayrımı ve wordpiece. #### __call__[[transformers.TapasTokenizer.__call__]] ```python __call__(table: typing.Union[ForwardRef('pd.DataFrame'), str, list[str], NoneType], queries: str | list[str] | list[int] | list[list[str]] | list[list[int]] | None = None, answer_coordinates: list[tuple] | list[list[tuple]] | None = None, answer_text: list[str] | list[list[str]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.models.tapas.tokenization_tapas.TapasTruncationStrategy = False, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L518) **Parametreler:** table (`pd.DataFrame` veya `str` veya `list[str]`) : Tablo verisi içeren tablo. Not: Tüm hücre değerleri metin olmalıdır. Bir Pandas veri çerçevesini string'e dönüştürmek için *.astype(str)* kullanın. Bir string veya string listesi geçirildiğinde, bunlar boş bir tabloyla sorgular olarak yorumlanır (genel tokenizer testlerini desteklemek için). queries (`str` veya `list[str]`) : Kodlanacak bir tabloyla ilgili soru veya soru partisi. Parti durumunda, tüm soruların **aynı** tabloya atıfta bulunması gerektiğini unutmayın. answer_coordinates (`list[Tuple]` veya `list[list[Tuple]]`, *isteğe bağlı*) : Batch'teki her tablo-soru çiftinin cevap koordinatları. Yalnızca tek bir tablo-soru çifti sağlanıyorsa, answer_coordinates bir veya daha fazla tuple içeren tek bir liste olmalıdır. Her tuple bir (row_index, column_index) çifti olmalıdır. İlk veri satırının (sütun başlık satırı değil) indeksi 0'dır. İlk sütunun indeksi 0'dır. Bir tablo-soru çiftleri batch'i sağlanıyorsa, answer_coordinates tuple listelerinin bir listesi olmalıdır (her liste tek bir tablo-soru çiftine karşılık gelir). answer_text (`list[str]` veya `list[list[str]]`, *isteğe bağlı*) : Batch'teki her tablo-soru çiftinin cevap metni. Yalnızca tek bir tablo-soru çifti sağlanıyorsa, answer_text bir veya daha fazla dizeden oluşan tek bir liste olmalıdır. Her dize, karşılık gelen bir cevap koordinatının cevap metni olmalıdır. Bir tablo-soru çiftleri batch'i sağlanıyorsa, answer_coordinates dizelerin listesi olan bir liste olmalıdır (her liste tek bir tablo-soru çiftine karşılık gelir). add_special_tokens (`bool`, *isteğe bağlı*, varsayılan `True`) : Sıraların, modellerine göre özel jetonlarla kodlanıp kodlanmayacağını belirtir. padding (`bool`, `str` veya [PaddingStrategy](/docs/transformers/main/tr/internal/file_utils#transformers.utils.PaddingStrategy), *opsiyonel*, varsayılan `False`) : Dolguyu (padding) etkinleştirir ve kontrol eder. Aşağıdaki değerleri kabul eder: - `True` veya `'longest'`: Batch'teki en uzun diziye kadar doldurur (yalnızca tek bir dizi sağlandıysa dolgu yapılmaz). - `'max_length'`: `max_length` argümanı ile belirtilen maksimum uzunluğa kadar veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum giriş uzunluğuna kadar doldurur. - `False` veya `'do_not_pad'` (varsayılan): Dolgu yapılmaz (yani, farklı uzunluklarda dizilere sahip bir batch çıktısı verilebilir). truncation (`bool`, `str` veya `TapasTruncationStrategy`, *opsiyonel*, varsayılan `False`) : Kırpma işlemini etkinleştirir ve kontrol eder. Aşağıdaki değerleri kabul eder: - `True` veya `'drop_rows_to_fit'`: `max_length` argümanı ile belirtilen maksimum uzunluğa veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum girdi uzunluğuna kırpılır. Bu işlem satır satır kırpma yaparak, tablodan satırları kaldırır. - `False` veya `'do_not_truncate'` (varsayılan): Kırpma yapılmaz (yani, modelin kabul edebileceği maksimum girdi boyutundan daha uzun dizi uzunluklarına sahip bir çıktı partisi üretilebilir). max_length (`int`, *opsiyonel*) : Kırpma/doldurma parametrelerinden biri tarafından kullanılacak olan maksimum uzunluğu kontrol eder. Ayarlanmaz veya `None` olarak ayarlanırsa, kırpma/doldurma parametrelerinden biri maksimum uzunluk gerektiriyorsa, önceden tanımlanmış modelin maksimum uzunluğu kullanılır. Modelin belirli bir maksimum giriş uzunluğu yoksa (XLNet gibi) maksimum uzunluğa kırpma/doldurma devre dışı bırakılır. is_split_into_words (`bool`, *isteğe bağlı*, varsayılan `False`) : Girdinin önceden tokenize edilip edilmediğini (örneğin, kelimelere ayrılmış olup olmadığını) belirtir. `True` olarak ayarlanırsa, tokenizer girdinin zaten kelimelere ayrılmış olduğunu (örneğin, boşluklara göre bölünmüş) varsayar ve bunları tokenize eder. Bu, NER veya token sınıflandırma için faydalıdır. pad_to_multiple_of (`int`, *isteğe bağlı*) : Ayarlanırsa, diziyi verilen değerin katına kadar doldurur. Bu, hesaplama yeteneği `>= 7.5` (Volta) olan NVIDIA donanımlarında Tensor Core'lerin kullanılmasını sağlamak için özellikle faydalıdır. return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, Python tamsayı listesi yerine tensörler döndürülür. Kabul edilen değerler: - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: Numpy `np.ndarray` nesnelerini döndürür. Bir tabloyla ilgili bir veya birden fazla diziyi belirteçlere ayırmak ve modele hazırlamak için kullanılan ana yöntem. #### convert_logits_to_predictions[[transformers.TapasTokenizer.convert_logits_to_predictions]] ```python convert_logits_to_predictions(data, logits, logits_agg = None, cell_classification_threshold = 0.5) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L1885) **Parametreler:** data (`dict`) : Özellikleri gerçek değerlere eşleyen sözlük. [TapasTokenizer](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasTokenizer) kullanılarak oluşturulmalıdır. logits (`torch.Tensor`, şekli `(batch_size, sequence_length)`) : Token düzeyindeki logit'leri içeren tensör. logits_agg (`torch.Tensor`, şekli `(batch_size, num_aggregation_labels)`, *isteğe bağlı*) : Toplama logitlerini içeren tensör. cell_classification_threshold (`float`, *opsiyonel*, varsayılan 0.5) : Hücre seçimi için kullanılacak eşik. Olasılığı bu eşiğin üzerinde olan tüm tablo hücreleri seçilecektir. **Dönüş:** Girdilere bağlı olarak çeşitli öğelerden oluşan `tuple` - predicted_answer_coordinates (`list[list[[tuple]]`, uzunluğu `batch_size`): Tahmin edilen cevap koordinatları, tuple listelerinin listesi olarak. Listedeki her öğe, batch içindeki tek bir örneğin tahmin edilen cevap koordinatlarını, tuple listesi olarak içerir. Her tuple bir hücredir, yani (satır indeksi, sütun indeksi). - predicted_aggregation_indices (`list[int]`, uzunluğu `batch_size`, *isteğe bağlı*, `logits_aggregation` sağlandığında döndürülür): Aggregation başlığının tahmini aggregation operatör indeksleri. [TapasForQuestionAnswering](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForQuestionAnswering) logits'ini gerçek tahmin edilen cevap koordinatlarına ve isteğe bağlı toplama indekslerine dönüştürür. Bu fonksiyonun dayandığı orijinal uygulama [burada](https://github.com/google-research/tapas/blob/4908213eb4df7aa988573350278b44c4dbe3f71b/tapas/experiments/prediction_utils.py#L288) bulunabilir. #### save_vocabulary[[transformers.TapasTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L386) ## TapasModel[[transformers.TapasModel]] #### transformers.TapasModel[[transformers.TapasModel]] ```python transformers.TapasModel(config: TapasConfig, add_pooling_layer = True) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L510) **Parametreler:** config ([TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın. add_pooling_layer (`bool`, *isteğe bağlı*, varsayılan `True`) : Bir havuzlama katmanı eklenip eklenmeyeceği Üzerinde herhangi bir özel head olmadan ham hidden-state'ler üreten çıplak Tapas Model. Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın. Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun. #### forward[[transformers.TapasModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L543) **Parametreler:** input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids) attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri: - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0. [Dikkat maskeleri nelerdir?](../glossary#attention-mask) token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length, 7)`, *isteğe bağlı*) : Tabular yapıyı kodlayan token indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Daha fazla bilgi için bu sınıfa bakın. [Token type ID'leri nelerdir?](../glossary#token-type-ids) position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizilerindeki her token'ın konum gömme (position embeddings) içindeki konum indeksleri. [TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)'nin `reset_position_index_per_cell` değeri `True` olarak ayarlanırsa, göreli konum gömme (relative position embeddings) kullanılacaktır. `[0, config.max_position_embeddings - 1]` aralığında seçilir. [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids) inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır. encoder_hidden_states (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : Kodlayıcının son katmanının çıktısındaki gizli durumlar dizisi. Model bir çözücü olarak yapılandırılmışsa çapraz dikkat (cross-attention) için kullanılır. encoder_attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Kodlayıcı girdisindeki dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. Model bir çözücü (decoder) olarak yapılandırılmışsa bu maske, çapraz dikkat (cross-attention) için kullanılır. `[0, 1]` aralığında seçilen maske değerleri: - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0. output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın. output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın. return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi? **Dönüş:** [BaseModelOutputWithPooling](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) veya `tuple(torch.Tensor)` [BaseModelOutputWithPooling](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [TapasModel](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasModel) forward metodu, `__call__` özel metodunu geçersiz kılar. İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar. - **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi. - **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- Sıralamanın ilk token'ının (sınıflandırma token'ı) son katman gizli durumu, yardımcı ön eğitim görevi için kullanılan katmanlardan geçirildikten sonraki hali. Örneğin BERT ailesi modelleri için, bu, sınıflandırma token'ının doğrusal bir katman ve tanh aktivasyon fonksiyonundan geçirildikten sonraki halini döndürür. Doğrusal katman ağırlıkları, ön eğitim sırasında bir sonraki cümle tahmini (sınıflandırma) hedefinden eğitilir. - **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet. Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları. - **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`. Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır. Örnekler: ```python >>> from transformers import AutoTokenizer, TapasModel >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base") >>> model = TapasModel.from_pretrained("google/tapas-base") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state ``` ## TapasForMaskedLM[[transformers.TapasForMaskedLM]] #### transformers.TapasForMaskedLM[[transformers.TapasForMaskedLM]] ```python transformers.TapasForMaskedLM(config: TapasConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L660) **Parametreler:** config ([TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın. Üstünde `language modeling` başlığı olan Tapas Modeli." Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın. Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun. #### forward[[transformers.TapasForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L684) **Parametreler:** input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids) attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri: - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0. [Dikkat maskeleri nelerdir?](../glossary#attention-mask) token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length, 7)`, *isteğe bağlı*) : Tabular yapıyı kodlayan token indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Daha fazla bilgi için bu sınıfa bakın. [Token type ID'leri nelerdir?](../glossary#token-type-ids) position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizilerindeki her token'ın konum gömme (position embeddings) içindeki konum indeksleri. [TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)'nin `reset_position_index_per_cell` değeri `True` olarak ayarlanırsa, göreli konum gömme (relative position embeddings) kullanılacaktır. `[0, config.max_position_embeddings - 1]` aralığında seçilir. [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids) inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır. encoder_hidden_states (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : Kodlayıcının son katmanının çıktısındaki gizli durumlar dizisi. Model bir çözücü olarak yapılandırılmışsa çapraz dikkat (cross-attention) için kullanılır. encoder_attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Kodlayıcı girdisindeki dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. Model bir çözücü (decoder) olarak yapılandırılmışsa bu maske, çapraz dikkat (cross-attention) için kullanılır. `[0, 1]` aralığında seçilen maske değerleri: - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0. labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[-100, 0, ..., config.vocab_size]` aralığında olmalıdır (bkz. `input_ids` docstring). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca etiketleri `[0, ..., config.vocab_size]` aralığında olan tokenlar için hesaplanır. output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın. output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın. return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi? **Dönüş:** [MaskedLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) veya `tuple(torch.Tensor)` [MaskedLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) veya `torch.Tensor` bir demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [TapasForMaskedLM](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForMaskedLM) forward metodu, `__call__` özel metodunu geçersiz kılar. İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar. - **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Maskeli dil modelleme (MLM) kaybı. - **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar). - **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet. Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları. - **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`. Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır. Örnekler: ```python >>> from transformers import AutoTokenizer, TapasForMaskedLM >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base") >>> model = TapasForMaskedLM.from_pretrained("google/tapas-base") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> inputs = tokenizer( ... table=table, queries="How many [MASK] has George [MASK] played in?", return_tensors="pt" ... ) >>> labels = tokenizer( ... table=table, queries="How many movies has George Clooney played in?", return_tensors="pt" ... )["input_ids"] >>> outputs = model(**inputs, labels=labels) >>> logits = outputs.logits ``` ## TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] #### transformers.TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] ```python transformers.TapasForSequenceClassification(config: TapasConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L1119) **Parametreler:** config ([TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın. Üstünde bir dizi sınıflandırma kafası (toplanmış çıktının üzerinde doğrusal bir katman) bulunan Tapas Modeli, örneğin TabFact (Chen et al., 2020) gibi tablo çıkarım görevleri için. Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın. Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun. #### forward[[transformers.TapasForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L1131) **Parametreler:** input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids) attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri: - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0. [Dikkat maskeleri nelerdir?](../glossary#attention-mask) token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length, 7)`, *isteğe bağlı*) : Tabular yapıyı kodlayan token indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Daha fazla bilgi için bu sınıfa bakın. [Token type ID'leri nelerdir?](../glossary#token-type-ids) position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizilerindeki her token'ın konum gömme (position embeddings) içindeki konum indeksleri. [TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)'nin `reset_position_index_per_cell` değeri `True` olarak ayarlanırsa, göreli konum gömme (relative position embeddings) kullanılacaktır. `[0, config.max_position_embeddings - 1]` aralığında seçilir. [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids) inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır. labels (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Sınıflandırma/geri dönüş kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. `config.num_labels == 1` ise bir geri dönüş kaybı (Ortalama Kare kaybı) hesaplanır, `config.num_labels > 1` ise bir sınıflandırma kaybı (Çapraz Entropi) hesaplanır. Not: Bu, orijinal uygulamada "classification_class_index" olarak adlandırılır. output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın. output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın. return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi? **Dönüş:** [SequenceClassifierOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) veya `tuple(torch.Tensor)` [SequenceClassifierOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [TapasForSequenceClassification](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForSequenceClassification) forward metodu, `__call__` özel metodunu geçersiz kılar. İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar. - **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Sınıflandırma (config.num_labels==1 ise regresyon) kaybı. - **logits** (`torch.Tensor`, şekli `(batch_size, config.num_labels)`) -- Sınıflandırma (veya config.num_labels==1 ise regresyon) puanları (SoftMax öncesi). - **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet. Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları. - **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`. Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır. Örnekler: ```python >>> from transformers import AutoTokenizer, TapasForSequenceClassification >>> import torch >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-tabfact") >>> model = TapasForSequenceClassification.from_pretrained("google/tapas-base-finetuned-tabfact") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = [ ... "There is only one actor who is 45 years old", ... "There are 3 actors which played in more than 60 movies", ... ] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> labels = torch.tensor([1, 0]) # 1 means entailed, 0 means refuted >>> outputs = model(**inputs, labels=labels) >>> loss = outputs.loss >>> logits = outputs.logits ``` ## TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] #### transformers.TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] ```python transformers.TapasForQuestionAnswering(config: TapasConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L781) **Parametreler:** config ([TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın. Tablo üzerinde soru-cevap görevleri için, üstünde hücre seçimi başlığı ve isteğe bağlı bir toplulaştırma başlığı bulunan Tapas Modeli (gizli durum çıktısının üzerine `logits` ve isteğe bağlı `logits_aggregation` hesaplamak için doğrusal katmanlar), örneğin SQA, WTQ veya WikiSQL ile denetimli görevler için. Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın. Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun. #### forward[[transformers.TapasForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, table_mask: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, aggregation_labels: typing.Optional[torch.LongTensor] = None, float_answer: typing.Optional[torch.Tensor] = None, numeric_values: typing.Optional[torch.Tensor] = None, numeric_values_scale: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L804) **Parametreler:** input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids) attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri: - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0. [Dikkat maskeleri nelerdir?](../glossary#attention-mask) token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length, 7)`, *isteğe bağlı*) : Tabular yapıyı kodlayan token indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Daha fazla bilgi için bu sınıfa bakın. [Token type ID'leri nelerdir?](../glossary#token-type-ids) position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizilerindeki her token'ın konum gömme (position embeddings) içindeki konum indeksleri. [TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)'nin `reset_position_index_per_cell` değeri `True` olarak ayarlanırsa, göreli konum gömme (relative position embeddings) kullanılacaktır. `[0, config.max_position_embeddings - 1]` aralığında seçilir. [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids) inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır. table_mask (`torch.LongTensor`, şekli `(batch_size, seq_length)`, *isteğe bağlı*) : Tablo için maske. Hangi token'ların tabloya ait olduğunu (1) belirtir. Soru token'ları, tablo başlıkları ve dolgu 0'dır. labels (`torch.LongTensor`, şekli `(batch_size, seq_length)`, *isteğe bağlı*) : Hiyerarşik hücre seçimi kaybını hesaplamak için token başına etiketler. Bu, tablodaki cevabın konumlarını kodlar. [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. - **cevabın parçası olan** tokenlar için - 1, **cevabın parçası olmayan** tokenlar için - 0. aggregation_labels (`torch.LongTensor`, şekli `(batch_size, )`, *isteğe bağlı*) : Toplama kaybını hesaplamak için batch'teki her örnek için toplama fonksiyonu indeksi. İndisler `[0, ..., config.num_aggregation_labels - 1]` aralığında olmalıdır. Yalnızca toplama için güçlü denetim (WikiSQL-supervised) durumunda gereklidir. float_answer (`torch.Tensor`, şekli `(batch_size, )`, *isteğe bağlı*) : Batch'teki her örnek için float cevabı. Hücre seçimi soruları için *float('nan')* olarak ayarlayın. Yalnızca zayıf denetim (WTQ) durumunda, toplam maskenin ve regresyon kaybının hesaplanması için gereklidir. numeric_values (`torch.Tensor`, şekli `(batch_size, seq_length)`, *isteğe bağlı*) : Her token'ın sayısal değeri, sayısal olmayan token'lar için NaN. [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Yalnızca, regresyon kaybını hesaplamak için agregasyonda zayıf denetim (WTQ) durumunda gereklidir. numeric_values_scale (`torch.Tensor`, şekli `(batch_size, seq_length)`, *isteğe bağlı*) : Her token'ın sayısal değerlerinin ölçeği. [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Yalnızca, regresyon kaybını hesaplamak için agregasyonda zayıf denetim (WTQ) durumunda gereklidir. output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın. output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın. return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi? **Dönüş:** [TableQuestionAnsweringOutput](/docs/transformers/main/tr/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) veya `tuple(torch.Tensor)` [TableQuestionAnsweringOutput](/docs/transformers/main/tr/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([TapasConfig](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [TapasForQuestionAnswering](/docs/transformers/main/tr/model_doc/tapas#transformers.TapasForQuestionAnswering) forward metodu, `__call__` özel metodunu geçersiz kılar. İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar. - **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` (ve olası olarak `answer`, `aggregation_labels`, `numeric_values` ve `numeric_values_scale` sağlandığında) döndürülür) -- Hiyerarşik hücre seçimi log-olabilirlik kaybının ve (isteğe bağlı olarak) yarı denetimli regresyon kaybının ve (isteğe bağlı olarak) agregasyonlar için denetimli kaybın toplamı olarak toplam kayıp. - **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length)`) -- Her token için hücre seçimi başlığının tahmin puanları. - **logits_aggregation** (`torch.Tensor`, *opsiyonel*, şekli `(batch_size, num_aggregation_labels)`) -- Her bir agregasyon operatörü için agregasyon başlığının tahmin puanları. - **hidden_states** (`tuple[torch.Tensor]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren ve `(batch_size, sequence_length, hidden_size)` biçiminde bir demet. Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları. - **attentions** (`tuple[torch.Tensor]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti. Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır. Örnekler: ```python >>> from transformers import AutoTokenizer, TapasForQuestionAnswering >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-wtq") >>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base-finetuned-wtq") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> logits = outputs.logits >>> logits_aggregation = outputs.logits_aggregation ```