






from collections import Counter

import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split

snake_case     					=		datasets.load_iris()

snake_case     					=		np.array(data["""data"""])
snake_case     					=		np.array(data["""target"""])
snake_case     					=		data["""target_names"""]

snake_case					, snake_case					, snake_case					, snake_case     					=		train_test_split(X, y)


def 	lowerCamelCase__      (  lowercase    ,  lowercase					):

  """simple docstring"""






  return np.linalg.norm(np.array(lowercase					) - np.array(lowercase					)					)


def 	lowerCamelCase__      (  lowercase    ,  lowercase    ,  lowercase    ,  lowercase    ,  lowercase=5					):

  """simple docstring"""






  SCREAMING_SNAKE_CASE							:   List[str]						    =     zip(lowercase    ,  lowercase					)
  # List of distances of all points from the point to be classified
  SCREAMING_SNAKE_CASE							:   Optional[int]						    =     []
  for data_point in data:
    SCREAMING_SNAKE_CASE							:   Tuple						    =     euclidean_distance(data_point[0]    ,  lowercase					)
    distances.append((distance, data_point[1])					)
  # Choosing 'k' points with the least distances.
  SCREAMING_SNAKE_CASE							:   List[Any]						    =     [i[1] for i in sorted(lowercase					)[:k]]
  # Most commonly occurring class among them
  # is the class into which the point is classified
  SCREAMING_SNAKE_CASE							:   List[Any]						    =     Counter(lowercase					).most_common(1					)[0][0]
  return classes[result]


if __name__ == "__main__":
   print(classifier(X_train, y_train, classes, [4.4, 3.1, 1.3, 1.4]))













import argparse

import torch

from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
from transformers.utils import logging


logging.set_verbosity_info()


def       UpperCamelCase__(			UpperCamelCase__     :			Any					,	UpperCamelCase__     :			int					,	UpperCamelCase__     :			List[Any]    )->Optional[int]:
       # Initialise PyTorch model
       A__		   =		RemBertConfig.from_json_file(UpperCamelCase__    )
       print('''Building PyTorch model from configuration: {}'''.format(str(UpperCamelCase__    )    )    )
       A__		   =		RemBertModel(UpperCamelCase__    )

       # Load weights from tf checkpoint
       load_tf_weights_in_rembert(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__    )

       # Save pytorch-model
       print('''Save PyTorch model to {}'''.format(UpperCamelCase__    )    )
       torch.save(model.state_dict()					,	UpperCamelCase__    )


if __name__ == "__main__":
       a__: List[Any]							   =						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(
           '--rembert_config_file',
           default=None,
           type=str,
           required=True,
           help=(
               'The config json file corresponding to the pre-trained RemBERT model. \n'
               'This specifies the model architecture.'
           ),
       )
       parser.add_argument(
           '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
       )
       a__: Union[str, Any]							   =						parser.parse_args()
       convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)





