



def        A       (      _lowerCamelCase						):





							'''simple docstring'''




							_lowerCAmelCase  :							Optional[Any]				     =					0
							_lowerCAmelCase  :							Optional[Any]				     =					len(_lowerCamelCase						)

							for i in range(n - 1						):
														for j in range(i + 1       ,				_lowerCamelCase						):
																					if arr[i] > arr[j]:
																												num_inversions += 1

							return num_inversions






def        A       (      _lowerCamelCase						):





							'''simple docstring'''




							if len(_lowerCamelCase						) <= 1:
														return arr, 0
							_lowerCAmelCase  :							List[str]				     =					len(_lowerCamelCase						) // 2
							_lowerCAmelCase  :							int				     =					arr[0:mid]
							_lowerCAmelCase  :							Dict				     =					arr[mid:]

							_lowerCAmelCase     ,					_lowerCAmelCase  :							Dict				     =					count_inversions_recursive(_lowerCamelCase						)
							_lowerCAmelCase     ,					_lowerCAmelCase  :							str				     =					count_inversions_recursive(_lowerCamelCase						)
							_lowerCAmelCase     ,					_lowerCAmelCase  :							Any				     =					_count_cross_inversions(_lowerCamelCase       ,				_lowerCamelCase						)

							_lowerCAmelCase  :							Union[str, Any]				     =					inversion_p + inversions_q + cross_inversions
							return c, num_inversions






def        A       (      _lowerCamelCase       ,				_lowerCamelCase						):





							'''simple docstring'''




							_lowerCAmelCase  :							List[Any]				     =					[]
							_lowerCAmelCase  :							List[str]				     =					0
							while i < len(_lowerCamelCase						) and j < len(_lowerCamelCase						):
														if p[i] > q[j]:
																					# if P[1] > Q[j], then P[k] > Q[k] for all  i < k <= len(P)
																					# These are all inversions. The claim emerges from the
																					# property that P is sorted.
																					num_inversion += len(_lowerCamelCase						) - i
																					r.append(q[j]						)
																					j += 1
														else:
																					r.append(p[i]						)
																					i += 1

							if i < len(_lowerCamelCase						):
														r.extend(p[i:]						)
							else:
														r.extend(q[j:]						)

							return r, num_inversion






def        A       (      ):





							'''simple docstring'''




							_lowerCAmelCase  :							Optional[Any]				     =					[10, 2, 1, 5, 5, 2, 11]

							# this arr has 8 inversions:
							# (10, 2), (10, 1), (10, 5), (10, 5), (10, 2), (2, 1), (5, 2), (5, 2)

							_lowerCAmelCase  :							List[Any]				     =					count_inversions_bf(_lowerCamelCase						)
							_lowerCAmelCase     ,					_lowerCAmelCase  :							List[str]				     =					count_inversions_recursive(_lowerCamelCase						)

							assert num_inversions_bf == num_inversions_recursive == 8

							print("number of inversions = "       ,				_lowerCamelCase						)

							# testing an array with zero inversion (a sorted arr_1)

							arr_a.sort()
							_lowerCAmelCase  :							Any				     =					count_inversions_bf(_lowerCamelCase						)
							_lowerCAmelCase     ,					_lowerCAmelCase  :							Union[str, Any]				     =					count_inversions_recursive(_lowerCamelCase						)

							assert num_inversions_bf == num_inversions_recursive == 0
							print("number of inversions = "       ,				_lowerCamelCase						)

							# an empty list should also have zero inversions
							_lowerCAmelCase  :							List[Any]				     =					[]
							_lowerCAmelCase  :							Tuple				     =					count_inversions_bf(_lowerCamelCase						)
							_lowerCAmelCase     ,					_lowerCAmelCase  :							List[Any]				     =					count_inversions_recursive(_lowerCamelCase						)

							assert num_inversions_bf == num_inversions_recursive == 0
							print("number of inversions = "       ,				_lowerCamelCase						)


if __name__ == "__main__":
						main()





import argparse
import os

import torch

from transformers import (
    XLNetConfig,
    XLNetForQuestionAnswering,
    XLNetForSequenceClassification,
    XLNetLMHeadModel,
    load_tf_weights_in_xlnet,
)
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


_snake_case	=						{
    "cola": 2,
    "mnli": 3,
    "mrpc": 2,
    "sst-2": 2,
    "sts-b": 1,
    "qqp": 2,
    "qnli": 2,
    "rte": 2,
    "wnli": 2,
}


logging.set_verbosity_info()






def        A       (      _lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase=None						):





							'''simple docstring'''




							_lowerCAmelCase  :							Optional[Any]				     =					XLNetConfig.from_json_file(_lowerCamelCase						)

							_lowerCAmelCase  :							Any				     =					finetuning_task.lower() if finetuning_task is not None else ""
							if finetuning_task in GLUE_TASKS_NUM_LABELS:
														print(F"Building PyTorch XLNetForSequenceClassification model from configuration: {config}"						)
														_lowerCAmelCase  :							Any				     =					finetuning_task
														_lowerCAmelCase  :							Any				     =					GLUE_TASKS_NUM_LABELS[finetuning_task]
														_lowerCAmelCase  :							Union[str, Any]				     =					XLNetForSequenceClassification(_lowerCamelCase						)
							elif "squad" in finetuning_task:
														_lowerCAmelCase  :							Union[str, Any]				     =					finetuning_task
														_lowerCAmelCase  :							Any				     =					XLNetForQuestionAnswering(_lowerCamelCase						)
							else:
														_lowerCAmelCase  :							Union[str, Any]				     =					XLNetLMHeadModel(_lowerCamelCase						)

							# Load weights from tf checkpoint
							load_tf_weights_in_xlnet(_lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase						)

							# Save pytorch-model
							_lowerCAmelCase  :							Optional[int]				     =					os.path.join(_lowerCamelCase       ,				_lowerCamelCase						)
							_lowerCAmelCase  :							Dict				     =					os.path.join(_lowerCamelCase       ,				_lowerCamelCase						)
							print(F"Save PyTorch model to {os.path.abspath(_lowerCamelCase						)}"						)
							torch.save(model.state_dict()       ,				_lowerCamelCase						)
							print(F"Save configuration file to {os.path.abspath(_lowerCamelCase						)}"						)
							with open(_lowerCamelCase       ,				"w"       ,				encoding="utf-8"						) as f:
														f.write(config.to_json_string()						)


if __name__ == "__main__":
						_snake_case	=						argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
						)
						parser.add_argument(
						    "--xlnet_config_file",
						    default=None,
						    type=str,
						    required=True,
						    help=(
						        "The config json file corresponding to the pre-trained XLNet model. \n"
						        "This specifies the model architecture."
						    ),
						)
						parser.add_argument(
						    "--pytorch_dump_folder_path",
						    default=None,
						    type=str,
						    required=True,
						    help="Path to the folder to store the PyTorch model or dataset/vocab.",
						)
						parser.add_argument(
						    "--finetuning_task",
						    default=None,
						    type=str,
						    help="Name of a task on which the XLNet TensorFlow model was fine-tuned",
						)
						_snake_case	=						parser.parse_args()
						print(args)

						convert_xlnet_checkpoint_to_pytorch(
						    args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
						)
