






'''simple docstring'''




import argparse
from collections import OrderedDict
from pathlib import Path

import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision.transforms import functional as F

from transformers import DetrImageProcessor, TableTransformerConfig, TableTransformerForObjectDetection
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCamelCase   :					Optional[Any]   							=  logging.get_logger(__name__)

# here we list all keys to be renamed (original name on the left, our name on the right)
__lowerCamelCase   :					Optional[Any]   							=  []
for i in range(6):
		# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
		rename_keys.append(
		    (f'''transformer.encoder.layers.{i}.self_attn.out_proj.weight''', f'''encoder.layers.{i}.self_attn.out_proj.weight''')
		)
		rename_keys.append(
		    (f'''transformer.encoder.layers.{i}.self_attn.out_proj.bias''', f'''encoder.layers.{i}.self_attn.out_proj.bias''')
		)
		rename_keys.append((f'''transformer.encoder.layers.{i}.linear1.weight''', f'''encoder.layers.{i}.fc1.weight'''))
		rename_keys.append((f'''transformer.encoder.layers.{i}.linear1.bias''', f'''encoder.layers.{i}.fc1.bias'''))
		rename_keys.append((f'''transformer.encoder.layers.{i}.linear2.weight''', f'''encoder.layers.{i}.fc2.weight'''))
		rename_keys.append((f'''transformer.encoder.layers.{i}.linear2.bias''', f'''encoder.layers.{i}.fc2.bias'''))
		rename_keys.append(
		    (f'''transformer.encoder.layers.{i}.norm1.weight''', f'''encoder.layers.{i}.self_attn_layer_norm.weight''')
		)
		rename_keys.append((f'''transformer.encoder.layers.{i}.norm1.bias''', f'''encoder.layers.{i}.self_attn_layer_norm.bias'''))
		rename_keys.append((f'''transformer.encoder.layers.{i}.norm2.weight''', f'''encoder.layers.{i}.final_layer_norm.weight'''))
		rename_keys.append((f'''transformer.encoder.layers.{i}.norm2.bias''', f'''encoder.layers.{i}.final_layer_norm.bias'''))
		# decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
		rename_keys.append(
		    (f'''transformer.decoder.layers.{i}.self_attn.out_proj.weight''', f'''decoder.layers.{i}.self_attn.out_proj.weight''')
		)
		rename_keys.append(
		    (f'''transformer.decoder.layers.{i}.self_attn.out_proj.bias''', f'''decoder.layers.{i}.self_attn.out_proj.bias''')
		)
		rename_keys.append(
		    (
		        f'''transformer.decoder.layers.{i}.multihead_attn.out_proj.weight''',
		        f'''decoder.layers.{i}.encoder_attn.out_proj.weight''',
		    )
		)
		rename_keys.append(
		    (
		        f'''transformer.decoder.layers.{i}.multihead_attn.out_proj.bias''',
		        f'''decoder.layers.{i}.encoder_attn.out_proj.bias''',
		    )
		)
		rename_keys.append((f'''transformer.decoder.layers.{i}.linear1.weight''', f'''decoder.layers.{i}.fc1.weight'''))
		rename_keys.append((f'''transformer.decoder.layers.{i}.linear1.bias''', f'''decoder.layers.{i}.fc1.bias'''))
		rename_keys.append((f'''transformer.decoder.layers.{i}.linear2.weight''', f'''decoder.layers.{i}.fc2.weight'''))
		rename_keys.append((f'''transformer.decoder.layers.{i}.linear2.bias''', f'''decoder.layers.{i}.fc2.bias'''))
		rename_keys.append(
		    (f'''transformer.decoder.layers.{i}.norm1.weight''', f'''decoder.layers.{i}.self_attn_layer_norm.weight''')
		)
		rename_keys.append((f'''transformer.decoder.layers.{i}.norm1.bias''', f'''decoder.layers.{i}.self_attn_layer_norm.bias'''))
		rename_keys.append(
		    (f'''transformer.decoder.layers.{i}.norm2.weight''', f'''decoder.layers.{i}.encoder_attn_layer_norm.weight''')
		)
		rename_keys.append(
		    (f'''transformer.decoder.layers.{i}.norm2.bias''', f'''decoder.layers.{i}.encoder_attn_layer_norm.bias''')
		)
		rename_keys.append((f'''transformer.decoder.layers.{i}.norm3.weight''', f'''decoder.layers.{i}.final_layer_norm.weight'''))
		rename_keys.append((f'''transformer.decoder.layers.{i}.norm3.bias''', f'''decoder.layers.{i}.final_layer_norm.bias'''))

# convolutional projection + query embeddings + layernorm of encoder + layernorm of decoder + class and bounding box heads
rename_keys.extend(
    [
        ('''input_proj.weight''', '''input_projection.weight'''),
        ('''input_proj.bias''', '''input_projection.bias'''),
        ('''query_embed.weight''', '''query_position_embeddings.weight'''),
        ('''transformer.encoder.norm.weight''', '''encoder.layernorm.weight'''),
        ('''transformer.encoder.norm.bias''', '''encoder.layernorm.bias'''),
        ('''transformer.decoder.norm.weight''', '''decoder.layernorm.weight'''),
        ('''transformer.decoder.norm.bias''', '''decoder.layernorm.bias'''),
        ('''class_embed.weight''', '''class_labels_classifier.weight'''),
        ('''class_embed.bias''', '''class_labels_classifier.bias'''),
        ('''bbox_embed.layers.0.weight''', '''bbox_predictor.layers.0.weight'''),
        ('''bbox_embed.layers.0.bias''', '''bbox_predictor.layers.0.bias'''),
        ('''bbox_embed.layers.1.weight''', '''bbox_predictor.layers.1.weight'''),
        ('''bbox_embed.layers.1.bias''', '''bbox_predictor.layers.1.bias'''),
        ('''bbox_embed.layers.2.weight''', '''bbox_predictor.layers.2.weight'''),
        ('''bbox_embed.layers.2.bias''', '''bbox_predictor.layers.2.bias'''),
    ]
)

def 	__UpperCAmelCase       ( __magic_name__     ,__magic_name__     ,__magic_name__						)->    List[str]:



			"""simple docstring"""



			snake_case_				:					Dict   =       state_dict.pop(__magic_name__						)
			snake_case_				:					List[Any]   =       val

def 	__UpperCAmelCase       ( __magic_name__						)->    List[str]:



			"""simple docstring"""



			snake_case_				:					str   =       OrderedDict()
			for key, value in state_dict.items():
						if "backbone.0.body" in key:
									snake_case_				:					Any   =       key.replace("backbone.0.body"     ,"backbone.conv_encoder.model"						)
									snake_case_				:					List[Any]   =       value
						else:
									snake_case_				:					Dict   =       value

			return new_state_dict

def 	__UpperCAmelCase       ( __magic_name__						)->    List[Any]:



			"""simple docstring"""



			snake_case_				:					str   =       ""

			# first: transformer encoder
			for i in range(6						):
						# read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
						snake_case_				:					Optional[int]   =       state_dict.pop(F'''{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight'''						)
						snake_case_				:					List[Any]   =       state_dict.pop(F'''{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias'''						)
						# next, add query, keys and values (in that order) to the state dict
						snake_case_				:					Tuple   =       in_proj_weight[:256, :]
						snake_case_				:					str   =       in_proj_bias[:256]
						snake_case_				:					Dict   =       in_proj_weight[256:512, :]
						snake_case_				:					Optional[Any]   =       in_proj_bias[256:512]
						snake_case_				:					Optional[int]   =       in_proj_weight[-256:, :]
						snake_case_				:					Tuple   =       in_proj_bias[-256:]
			# next: transformer decoder (which is a bit more complex because it also includes cross-attention)
			for i in range(6						):
						# read in weights + bias of input projection layer of self-attention
						snake_case_				:					Tuple   =       state_dict.pop(F'''{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight'''						)
						snake_case_				:					Any   =       state_dict.pop(F'''{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias'''						)
						# next, add query, keys and values (in that order) to the state dict
						snake_case_				:					int   =       in_proj_weight[:256, :]
						snake_case_				:					List[Any]   =       in_proj_bias[:256]
						snake_case_				:					List[Any]   =       in_proj_weight[256:512, :]
						snake_case_				:					List[str]   =       in_proj_bias[256:512]
						snake_case_				:					Dict   =       in_proj_weight[-256:, :]
						snake_case_				:					int   =       in_proj_bias[-256:]
						# read in weights + bias of input projection layer of cross-attention
						snake_case_				:					Optional[int]   =       state_dict.pop(
						    F'''{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight'''						)
						snake_case_				:					Union[str, Any]   =       state_dict.pop(F'''{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias'''						)
						# next, add query, keys and values (in that order) of cross-attention to the state dict
						snake_case_				:					int   =       in_proj_weight_cross_attn[:256, :]
						snake_case_				:					Optional[Any]   =       in_proj_bias_cross_attn[:256]
						snake_case_				:					Any   =       in_proj_weight_cross_attn[256:512, :]
						snake_case_				:					Optional[int]   =       in_proj_bias_cross_attn[256:512]
						snake_case_				:					Optional[Any]   =       in_proj_weight_cross_attn[-256:, :]
						snake_case_				:					Any   =       in_proj_bias_cross_attn[-256:]

def 	__UpperCAmelCase       ( __magic_name__     ,__magic_name__						)->    Tuple:



			"""simple docstring"""



			snake_case_				:					Optional[int]   =       image.size
			snake_case_				:					Dict   =       max(__magic_name__     ,__magic_name__						)
			snake_case_				:					Optional[int]   =       800 if "detection" in checkpoint_url else 1000
			snake_case_				:					Optional[int]   =       target_max_size / current_max_size
			snake_case_				:					str   =       image.resize((int(round(scale * width						)						), int(round(scale * height						)						))						)

			return resized_image

def 	__UpperCAmelCase       ( __magic_name__						)->    Tuple:



			"""simple docstring"""



			snake_case_				:					Union[str, Any]   =       F.to_tensor(__magic_name__						)
			snake_case_				:					List[Any]   =       F.normalize(__magic_name__     ,mean=[0.485, 0.456, 0.406]     ,std=[0.229, 0.224, 0.225]						)
			return image

@torch.no_grad()
def 	__UpperCAmelCase       ( __magic_name__     ,__magic_name__     ,__magic_name__						)->    Tuple:



			"""simple docstring"""



			logger.info("Converting model..."						)

			# load original state dict
			snake_case_				:					str   =       torch.hub.load_state_dict_from_url(__magic_name__     ,map_location="cpu"						)
			# rename keys
			for src, dest in rename_keys:
						rename_key(__magic_name__     ,__magic_name__     ,__magic_name__						)
			snake_case_				:					Dict   =       rename_backbone_keys(__magic_name__						)
			# query, key and value matrices need special treatment
			read_in_q_k_v(__magic_name__						)
			# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
			snake_case_				:					Tuple   =       "model."
			for key in state_dict.copy().keys():
						if not key.startswith("class_labels_classifier"						) and not key.startswith("bbox_predictor"						):
									snake_case_				:					str   =       state_dict.pop(__magic_name__						)
									snake_case_				:					int   =       val
    # create HuggingFace model and load state dict
			snake_case_				:					List[str]   =       TableTransformerConfig(
			    backbone="resnet18"     ,mask_loss_coefficient=1     ,dice_loss_coefficient=1     ,ce_loss_coefficient=1     ,bbox_loss_coefficient=5     ,giou_loss_coefficient=2     ,eos_coefficient=0.4     ,class_cost=1     ,bbox_cost=5     ,giou_cost=2     ,)

			if "detection" in checkpoint_url:
						snake_case_				:					str   =       15
						snake_case_				:					Tuple   =       2
						snake_case_				:					Any   =       {0: "table", 1: "table rotated"}
						snake_case_				:					List[str]   =       idalabel
						snake_case_				:					Optional[int]   =       {v: k for k, v in idalabel.items()}
			else:
						snake_case_				:					int   =       125
						snake_case_				:					List[Any]   =       6
						snake_case_				:					str   =       {
						    0: "table",
						    1: "table column",
						    2: "table row",
						    3: "table column header",
						    4: "table projected row header",
						    5: "table spanning cell",
						}
						snake_case_				:					Any   =       idalabel
						snake_case_				:					int   =       {v: k for k, v in idalabel.items()}

			snake_case_				:					List[str]   =       DetrImageProcessor(
			    format="coco_detection"     ,max_size=800 if "detection" in checkpoint_url else 1000						)
			snake_case_				:					Optional[Any]   =       TableTransformerForObjectDetection(__magic_name__						)
			model.load_state_dict(__magic_name__						)
			model.eval()

			# verify our conversion
			snake_case_				:					Dict   =       "example_pdf.png" if "detection" in checkpoint_url else "example_table.png"
			snake_case_				:					List[str]   =       hf_hub_download(repo_id="nielsr/example-pdf"     ,repo_type="dataset"     ,filename=__magic_name__						)
			snake_case_				:					Any   =       Image.open(__magic_name__						).convert("RGB"						)
			snake_case_				:					Optional[int]   =       normalize(resize(__magic_name__     ,__magic_name__						)						).unsqueeze(0						)

			snake_case_				:					Optional[Any]   =       model(__magic_name__						)

			if "detection" in checkpoint_url:
						snake_case_				:					Optional[Any]   =       (1, 15, 3)
						snake_case_				:					Union[str, Any]   =       torch.tensor(
						    [[-6.7_897, -16.9_985, 6.7_937], [-8.0_186, -22.2_192, 6.9_677], [-7.3_117, -21.0_708, 7.4_055]]						)
						snake_case_				:					int   =       torch.tensor([[0.4_867, 0.1_767, 0.6_732], [0.6_718, 0.4_479, 0.3_830], [0.4_716, 0.1_760, 0.6_364]]						)

			else:
						snake_case_				:					Any   =       (1, 125, 7)
						snake_case_				:					Dict   =       torch.tensor(
						    [[-18.1_430, -8.3_214, 4.8_274], [-18.4_685, -7.1_361, -4.2_667], [-26.3_693, -9.3_429, -4.9_962]]						)
						snake_case_				:					Optional[Any]   =       torch.tensor([[0.4_983, 0.5_595, 0.9_440], [0.4_916, 0.6_315, 0.5_954], [0.6_108, 0.8_637, 0.1_135]]						)

			assert outputs.logits.shape == expected_shape
			assert torch.allclose(outputs.logits[0, :3, :3]     ,__magic_name__     ,atol=1E-4						)
			assert torch.allclose(outputs.pred_boxes[0, :3, :3]     ,__magic_name__     ,atol=1E-4						)
			print("Looks ok!"						)

			if pytorch_dump_folder_path is not None:
						# Save model and image processor
						logger.info(F'''Saving PyTorch model and image processor to {pytorch_dump_folder_path}...'''						)
						Path(__magic_name__						).mkdir(exist_ok=__magic_name__						)
						model.save_pretrained(__magic_name__						)
						image_processor.save_pretrained(__magic_name__						)

			if push_to_hub:
						# Push model to HF hub
						logger.info("Pushing model to the hub..."						)
						snake_case_				:					str   =       (
						    "microsoft/table-transformer-detection"
						    if "detection" in checkpoint_url
						    else "microsoft/table-transformer-structure-recognition"
						)
						model.push_to_hub(__magic_name__						)
						image_processor.push_to_hub(__magic_name__						)


if __name__ == "__main__":
		__lowerCamelCase   :					List[str]   							=  argparse.ArgumentParser()

		parser.add_argument(
		    '''--checkpoint_url''',
		    default='''https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth''',
		    type=str,
		    choices=[
		        '''https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth''',
		        '''https://pubtables1m.blob.core.windows.net/model/pubtables1m_structure_detr_r18.pth''',
		    ],
		    help='''URL of the Table Transformer checkpoint you\'d like to convert.''',
		)
		parser.add_argument(
		    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the folder to output PyTorch model.'''
		)
		parser.add_argument(
		    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
		)
		__lowerCamelCase   :					Dict   							=  parser.parse_args()
		convert_table_transformer_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)












'''simple docstring'''




import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
__lowerCamelCase   :					List[str]   							=					{'''LayoutLMv2Config''', '''LayoutLMv3Config'''}







@is_pipeline_test
class    A_	(unittest.TestCase							):
							"""simple docstring"""




							a__   		=	MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
							a__   		=	TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

							if model_mapping is not None:
														a__   		=	{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
							if tf_model_mapping is not None:
														a__   		=	{
														    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
														}

							def 							_A	(		self			:Tuple       ,							lowerCAmelCase__			:Tuple       ,							lowerCAmelCase__			:Union[str, Any]       ,							lowerCAmelCase__			:Dict				)				->  Any:


										'''simple docstring'''




										snake_case_				:					Optional[Any]   =       ZeroShotClassificationPipeline(
										    model=lowerCAmelCase__       ,							tokenizer=lowerCAmelCase__       ,							candidate_labels=["polics", "health"]				)
										return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]

							def 							_A	(		self			:List[str]       ,							lowerCAmelCase__			:Optional[int]       ,							lowerCAmelCase__			:Any				)				->  Optional[Any]:


										'''simple docstring'''




										snake_case_				:					Tuple   =       classifier("Who are you voting for in 2020?"       ,							candidate_labels="politics"				)
										self.assertEqual(lowerCAmelCase__       ,							{"sequence": ANY(lowerCAmelCase__				), "labels": [ANY(lowerCAmelCase__				)], "scores": [ANY(lowerCAmelCase__				)]}				)

										# No kwarg
										snake_case_				:					List[Any]   =       classifier("Who are you voting for in 2020?"       ,							["politics"]				)
										self.assertEqual(lowerCAmelCase__       ,							{"sequence": ANY(lowerCAmelCase__				), "labels": [ANY(lowerCAmelCase__				)], "scores": [ANY(lowerCAmelCase__				)]}				)

										snake_case_				:					Dict   =       classifier("Who are you voting for in 2020?"       ,							candidate_labels=["politics"]				)
										self.assertEqual(lowerCAmelCase__       ,							{"sequence": ANY(lowerCAmelCase__				), "labels": [ANY(lowerCAmelCase__				)], "scores": [ANY(lowerCAmelCase__				)]}				)

										snake_case_				:					int   =       classifier("Who are you voting for in 2020?"       ,							candidate_labels="politics, public health"				)
										self.assertEqual(
										    lowerCAmelCase__       ,							{"sequence": ANY(lowerCAmelCase__				), "labels": [ANY(lowerCAmelCase__				), ANY(lowerCAmelCase__				)], "scores": [ANY(lowerCAmelCase__				), ANY(lowerCAmelCase__				)]}				)
										self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]				)				)       ,							1.0				)

										snake_case_				:					Optional[int]   =       classifier("Who are you voting for in 2020?"       ,							candidate_labels=["politics", "public health"]				)
										self.assertEqual(
										    lowerCAmelCase__       ,							{"sequence": ANY(lowerCAmelCase__				), "labels": [ANY(lowerCAmelCase__				), ANY(lowerCAmelCase__				)], "scores": [ANY(lowerCAmelCase__				), ANY(lowerCAmelCase__				)]}				)
										self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]				)				)       ,							1.0				)

										snake_case_				:					str   =       classifier(
										    "Who are you voting for in 2020?"       ,							candidate_labels="politics"       ,							hypothesis_template="This text is about {}"				)
										self.assertEqual(lowerCAmelCase__       ,							{"sequence": ANY(lowerCAmelCase__				), "labels": [ANY(lowerCAmelCase__				)], "scores": [ANY(lowerCAmelCase__				)]}				)

										# https://github.com/huggingface/transformers/issues/13846
										snake_case_				:					Dict   =       classifier(["I am happy"]       ,							["positive", "negative"]				)
										self.assertEqual(
										    lowerCAmelCase__       ,							[
										        {"sequence": ANY(lowerCAmelCase__				), "labels": [ANY(lowerCAmelCase__				), ANY(lowerCAmelCase__				)], "scores": [ANY(lowerCAmelCase__				), ANY(lowerCAmelCase__				)]}
										        for i in range(1				)
										    ]       ,							)
										snake_case_				:					Tuple   =       classifier(["I am happy", "I am sad"]       ,							["positive", "negative"]				)
										self.assertEqual(
										    lowerCAmelCase__       ,							[
										        {"sequence": ANY(lowerCAmelCase__				), "labels": [ANY(lowerCAmelCase__				), ANY(lowerCAmelCase__				)], "scores": [ANY(lowerCAmelCase__				), ANY(lowerCAmelCase__				)]}
										        for i in range(2				)
										    ]       ,							)

										with self.assertRaises(lowerCAmelCase__				):
													classifier(""       ,							candidate_labels="politics"				)

										with self.assertRaises(lowerCAmelCase__				):
													classifier(lowerCAmelCase__       ,							candidate_labels="politics"				)

										with self.assertRaises(lowerCAmelCase__				):
													classifier("Who are you voting for in 2020?"       ,							candidate_labels=""				)

										with self.assertRaises(lowerCAmelCase__				):
													classifier("Who are you voting for in 2020?"       ,							candidate_labels=lowerCAmelCase__				)

										with self.assertRaises(lowerCAmelCase__				):
													classifier(
													    "Who are you voting for in 2020?"       ,							candidate_labels="politics"       ,							hypothesis_template="Not formatting template"       ,							)

										with self.assertRaises(lowerCAmelCase__				):
													classifier(
													    "Who are you voting for in 2020?"       ,							candidate_labels="politics"       ,							hypothesis_template=lowerCAmelCase__       ,							)

										self.run_entailment_id(lowerCAmelCase__				)

							def 							_A	(		self			:List[Any]       ,							lowerCAmelCase__			:Pipeline				)				->  Union[str, Any]:


										'''simple docstring'''




										snake_case_				:					int   =       zero_shot_classifier.model.config
										snake_case_				:					Optional[int]   =       config.labelaid
										snake_case_				:					Tuple   =       zero_shot_classifier.entailment_id

										snake_case_				:					Optional[Any]   =       {"LABEL_0": 0, "LABEL_1": 1, "LABEL_2": 2}
										self.assertEqual(zero_shot_classifier.entailment_id       ,							-1				)

										snake_case_				:					Tuple   =       {"entailment": 0, "neutral": 1, "contradiction": 2}
										self.assertEqual(zero_shot_classifier.entailment_id       ,							0				)

										snake_case_				:					str   =       {"ENTAIL": 0, "NON-ENTAIL": 1}
										self.assertEqual(zero_shot_classifier.entailment_id       ,							0				)

										snake_case_				:					str   =       {"ENTAIL": 2, "NEUTRAL": 1, "CONTR": 0}
										self.assertEqual(zero_shot_classifier.entailment_id       ,							2				)

										snake_case_				:					List[str]   =       original_labelaid
										self.assertEqual(lowerCAmelCase__       ,							zero_shot_classifier.entailment_id				)

							@require_torch
							def 							_A	(		self			:Tuple				)				->  Any:


										'''simple docstring'''




										snake_case_				:					List[Any]   =       pipeline(
										    "zero-shot-classification"       ,							model="sshleifer/tiny-distilbert-base-cased-distilled-squad"       ,							framework="pt"       ,							)
										# There was a regression in 4.10 for this
										# Adding a test so we don't make the mistake again.
										# https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
										zero_shot_classifier(
										    "Who are you voting for in 2020?" * 100       ,							candidate_labels=["politics", "public health", "science"]				)

							@require_torch
							def 							_A	(		self			:Optional[Any]				)				->  Tuple:


										'''simple docstring'''




										snake_case_				:					Union[str, Any]   =       pipeline(
										    "zero-shot-classification"       ,							model="sshleifer/tiny-distilbert-base-cased-distilled-squad"       ,							framework="pt"       ,							)
										snake_case_				:					int   =       zero_shot_classifier(
										    "Who are you voting for in 2020?"       ,							candidate_labels=["politics", "public health", "science"]				)

										self.assertEqual(
										    nested_simplify(lowerCAmelCase__				)       ,							{
										        "sequence": "Who are you voting for in 2020?",
										        "labels": ["science", "public health", "politics"],
										        "scores": [0.3_3_3, 0.3_3_3, 0.3_3_3],
										    }       ,							)

							@require_tf
							def 							_A	(		self			:Union[str, Any]				)				->  Dict:


										'''simple docstring'''




										snake_case_				:					List[str]   =       pipeline(
										    "zero-shot-classification"       ,							model="sshleifer/tiny-distilbert-base-cased-distilled-squad"       ,							framework="tf"       ,							)
										snake_case_				:					Optional[int]   =       zero_shot_classifier(
										    "Who are you voting for in 2020?"       ,							candidate_labels=["politics", "public health", "science"]				)

										self.assertEqual(
										    nested_simplify(lowerCAmelCase__				)       ,							{
										        "sequence": "Who are you voting for in 2020?",
										        "labels": ["science", "public health", "politics"],
										        "scores": [0.3_3_3, 0.3_3_3, 0.3_3_3],
										    }       ,							)

							@slow
							@require_torch
							def 							_A	(		self			:Union[str, Any]				)				->  int:


										'''simple docstring'''




										snake_case_				:					int   =       pipeline("zero-shot-classification"       ,							model="roberta-large-mnli"       ,							framework="pt"				)
										snake_case_				:					str   =       zero_shot_classifier(
										    "Who are you voting for in 2020?"       ,							candidate_labels=["politics", "public health", "science"]				)

										self.assertEqual(
										    nested_simplify(lowerCAmelCase__				)       ,							{
										        "sequence": "Who are you voting for in 2020?",
										        "labels": ["politics", "public health", "science"],
										        "scores": [0.9_7_6, 0.0_1_5, 0.0_0_9],
										    }       ,							)
										snake_case_				:					Optional[int]   =       zero_shot_classifier(
										    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
										    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
										    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
										    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
										    " machine translation tasks show these models to be superior in quality while being more parallelizable"
										    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
										    " English-to-German translation task, improving over the existing best results, including ensembles by"
										    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
										    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
										    " fraction of the training costs of the best models from the literature. We show that the Transformer"
										    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
										    " large and limited training data."       ,							candidate_labels=["machine learning", "statistics", "translation", "vision"]       ,							multi_label=lowerCAmelCase__       ,							)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__				)       ,							{
										        "sequence": (
										            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
										            " networks in an encoder-decoder configuration. The best performing models also connect the"
										            " encoder and decoder through an attention mechanism. We propose a new simple network"
										            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
										            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
										            " superior in quality while being more parallelizable and requiring significantly less time to"
										            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
										            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
										            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
										            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
										            " costs of the best models from the literature. We show that the Transformer generalizes well to"
										            " other tasks by applying it successfully to English constituency parsing both with large and"
										            " limited training data."
										        ),
										        "labels": ["translation", "machine learning", "vision", "statistics"],
										        "scores": [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
										    }       ,							)






							@slow
							@require_tf
							def 							_A	(		self			:List[str]				)				->  str:


										'''simple docstring'''




										snake_case_				:					int   =       pipeline("zero-shot-classification"       ,							model="roberta-large-mnli"       ,							framework="tf"				)
										snake_case_				:					Optional[Any]   =       zero_shot_classifier(
										    "Who are you voting for in 2020?"       ,							candidate_labels=["politics", "public health", "science"]				)

										self.assertEqual(
										    nested_simplify(lowerCAmelCase__				)       ,							{
										        "sequence": "Who are you voting for in 2020?",
										        "labels": ["politics", "public health", "science"],
										        "scores": [0.9_7_6, 0.0_1_5, 0.0_0_9],
										    }       ,							)
										snake_case_				:					Tuple   =       zero_shot_classifier(
										    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
										    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
										    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
										    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
										    " machine translation tasks show these models to be superior in quality while being more parallelizable"
										    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
										    " English-to-German translation task, improving over the existing best results, including ensembles by"
										    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
										    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
										    " fraction of the training costs of the best models from the literature. We show that the Transformer"
										    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
										    " large and limited training data."       ,							candidate_labels=["machine learning", "statistics", "translation", "vision"]       ,							multi_label=lowerCAmelCase__       ,							)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__				)       ,							{
										        "sequence": (
										            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
										            " networks in an encoder-decoder configuration. The best performing models also connect the"
										            " encoder and decoder through an attention mechanism. We propose a new simple network"
										            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
										            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
										            " superior in quality while being more parallelizable and requiring significantly less time to"
										            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
										            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
										            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
										            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
										            " costs of the best models from the literature. We show that the Transformer generalizes well to"
										            " other tasks by applying it successfully to English constituency parsing both with large and"
										            " limited training data."
										        ),
										        "labels": ["translation", "machine learning", "vision", "statistics"],
										        "scores": [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
										    }       ,							)




