





import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
					import torch

if is_vision_available():
					from PIL import Image

					from transformers import DeformableDetrImageProcessor

class     __SCREAMING_SNAKE_CASE   (       unittest.TestCase    ):






							def __init__(  self					,	__lowerCAmelCase					,	__lowerCAmelCase=7					,	__lowerCAmelCase=3					,	__lowerCAmelCase=30					,	__lowerCAmelCase=400					,	__lowerCAmelCase=True					,	__lowerCAmelCase=None					,	__lowerCAmelCase=True					,	__lowerCAmelCase=[0.5, 0.5, 0.5]					,	__lowerCAmelCase=[0.5, 0.5, 0.5]					,	__lowerCAmelCase=True					,	__lowerCAmelCase=1 / 255					,	__lowerCAmelCase=True					,	):
														# by setting size["longest_edge"] > max_resolution we're effectively not testing this :p
														UpperCamelCase__			       =     size if size is not None else {"""shortest_edge""": 18, """longest_edge""": 1333}
														UpperCamelCase__			       =     parent
														UpperCamelCase__			       =     batch_size
														UpperCamelCase__			       =     num_channels
														UpperCamelCase__			       =     min_resolution
														UpperCamelCase__			       =     max_resolution
														UpperCamelCase__			       =     do_resize
														UpperCamelCase__			       =     size
														UpperCamelCase__			       =     do_normalize
														UpperCamelCase__			       =     image_mean
														UpperCamelCase__			       =     image_std
														UpperCamelCase__			       =     do_rescale
														UpperCamelCase__			       =     rescale_factor
														UpperCamelCase__			       =     do_pad






							def 			_lowerCamelCase						(  self					):
														return {
														    "do_resize": self.do_resize,
														    "size": self.size,
														    "do_normalize": self.do_normalize,
														    "image_mean": self.image_mean,
														    "image_std": self.image_std,
														    "do_rescale": self.do_rescale,
														    "rescale_factor": self.rescale_factor,
														    "do_pad": self.do_pad,
														}







							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase=False					):
														if not batched:
																					UpperCamelCase__			       =     image_inputs[0]
																					if isinstance(__lowerCAmelCase					,	Image.Image					):
																												UpperCamelCase__       ,       UpperCamelCase__			       =     image.size
																					else:
																												UpperCamelCase__       ,       UpperCamelCase__			       =     image.shape[1], image.shape[2]
																					if w < h:
																												UpperCamelCase__			       =     int(self.size["""shortest_edge"""] * h / w					)
																												UpperCamelCase__			       =     self.size["""shortest_edge"""]
																					elif w > h:
																												UpperCamelCase__			       =     self.size["""shortest_edge"""]
																												UpperCamelCase__			       =     int(self.size["""shortest_edge"""] * w / h					)
																					else:
																												UpperCamelCase__			       =     self.size["""shortest_edge"""]
																												UpperCamelCase__			       =     self.size["""shortest_edge"""]

														else:
																					UpperCamelCase__			       =     []
																					for image in image_inputs:
																												UpperCamelCase__       ,       UpperCamelCase__			       =     self.get_expected_values([image]					)
																												expected_values.append((expected_height, expected_width)					)
																					UpperCamelCase__			       =     max(__lowerCAmelCase					,	key=lambda __lowerCAmelCase					: item[0]					)[0]
																					UpperCamelCase__			       =     max(__lowerCAmelCase					,	key=lambda __lowerCAmelCase					: item[1]					)[1]

														return expected_height, expected_width






@require_torch
@require_vision
class     __SCREAMING_SNAKE_CASE   (       _a				,						unittest.TestCase    ):
							snake_case       : Union[str, Any]         =    DeformableDetrImageProcessor if is_vision_available() else None






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     DeformableDetrImageProcessingTester(self					)






							@property
							def 			_lowerCamelCase						(  self					):
														return self.image_processor_tester.prepare_image_processor_dict()






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     self.image_processing_class(**self.image_processor_dict					)
														self.assertTrue(hasattr(__lowerCAmelCase					,	"""image_mean"""					)					)
														self.assertTrue(hasattr(__lowerCAmelCase					,	"""image_std"""					)					)
														self.assertTrue(hasattr(__lowerCAmelCase					,	"""do_normalize"""					)					)
														self.assertTrue(hasattr(__lowerCAmelCase					,	"""do_resize"""					)					)
														self.assertTrue(hasattr(__lowerCAmelCase					,	"""do_rescale"""					)					)
														self.assertTrue(hasattr(__lowerCAmelCase					,	"""do_pad"""					)					)
														self.assertTrue(hasattr(__lowerCAmelCase					,	"""size"""					)					)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     self.image_processing_class.from_dict(self.image_processor_dict					)
														self.assertEqual(image_processor.size					,	{"""shortest_edge""": 18, """longest_edge""": 1333}					)
														self.assertEqual(image_processor.do_pad					,	__lowerCAmelCase					)

														UpperCamelCase__			       =     self.image_processing_class.from_dict(
														    self.image_processor_dict					,	size=42					,	max_size=84					,	pad_and_return_pixel_mask=__lowerCAmelCase					)
														self.assertEqual(image_processor.size					,	{"""shortest_edge""": 42, """longest_edge""": 84}					)
														self.assertEqual(image_processor.do_pad					,	__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
														pass






							def 			_lowerCamelCase						(  self					):
														# Initialize image_processing
														UpperCamelCase__			       =     self.image_processing_class(**self.image_processor_dict					)
														# create random PIL images
														UpperCamelCase__			       =     prepare_image_inputs(self.image_processor_tester					,	equal_resolution=__lowerCAmelCase					)
														for image in image_inputs:
																					self.assertIsInstance(__lowerCAmelCase					,	Image.Image					)

														# Test not batched input
														UpperCamelCase__			       =     image_processing(image_inputs[0]					,	return_tensors="""pt"""					).pixel_values

														UpperCamelCase__       ,       UpperCamelCase__			       =     self.image_processor_tester.get_expected_values(__lowerCAmelCase					)

														self.assertEqual(
														    encoded_images.shape					,	(1, self.image_processor_tester.num_channels, expected_height, expected_width)					,	)

														# Test batched
														UpperCamelCase__       ,       UpperCamelCase__			       =     self.image_processor_tester.get_expected_values(__lowerCAmelCase					,	batched=__lowerCAmelCase					)

														UpperCamelCase__			       =     image_processing(__lowerCAmelCase					,	return_tensors="""pt"""					).pixel_values
														self.assertEqual(
														    encoded_images.shape					,	(
														        self.image_processor_tester.batch_size,
														        self.image_processor_tester.num_channels,
														        expected_height,
														        expected_width,
														    )					,	)






							def 			_lowerCamelCase						(  self					):
														# Initialize image_processing
														UpperCamelCase__			       =     self.image_processing_class(**self.image_processor_dict					)
														# create random numpy tensors
														UpperCamelCase__			       =     prepare_image_inputs(self.image_processor_tester					,	equal_resolution=__lowerCAmelCase					,	numpify=__lowerCAmelCase					)
														for image in image_inputs:
																					self.assertIsInstance(__lowerCAmelCase					,	np.ndarray					)

														# Test not batched input
														UpperCamelCase__			       =     image_processing(image_inputs[0]					,	return_tensors="""pt"""					).pixel_values

														UpperCamelCase__       ,       UpperCamelCase__			       =     self.image_processor_tester.get_expected_values(__lowerCAmelCase					)

														self.assertEqual(
														    encoded_images.shape					,	(1, self.image_processor_tester.num_channels, expected_height, expected_width)					,	)

														# Test batched
														UpperCamelCase__			       =     image_processing(__lowerCAmelCase					,	return_tensors="""pt"""					).pixel_values

														UpperCamelCase__       ,       UpperCamelCase__			       =     self.image_processor_tester.get_expected_values(__lowerCAmelCase					,	batched=__lowerCAmelCase					)

														self.assertEqual(
														    encoded_images.shape					,	(
														        self.image_processor_tester.batch_size,
														        self.image_processor_tester.num_channels,
														        expected_height,
														        expected_width,
														    )					,	)






							def 			_lowerCamelCase						(  self					):
														# Initialize image_processing
														UpperCamelCase__			       =     self.image_processing_class(**self.image_processor_dict					)
														# create random PyTorch tensors
														UpperCamelCase__			       =     prepare_image_inputs(self.image_processor_tester					,	equal_resolution=__lowerCAmelCase					,	torchify=__lowerCAmelCase					)
														for image in image_inputs:
																					self.assertIsInstance(__lowerCAmelCase					,	torch.Tensor					)

														# Test not batched input
														UpperCamelCase__			       =     image_processing(image_inputs[0]					,	return_tensors="""pt"""					).pixel_values

														UpperCamelCase__       ,       UpperCamelCase__			       =     self.image_processor_tester.get_expected_values(__lowerCAmelCase					)

														self.assertEqual(
														    encoded_images.shape					,	(1, self.image_processor_tester.num_channels, expected_height, expected_width)					,	)

														# Test batched
														UpperCamelCase__			       =     image_processing(__lowerCAmelCase					,	return_tensors="""pt"""					).pixel_values

														UpperCamelCase__       ,       UpperCamelCase__			       =     self.image_processor_tester.get_expected_values(__lowerCAmelCase					,	batched=__lowerCAmelCase					)

														self.assertEqual(
														    encoded_images.shape					,	(
														        self.image_processor_tester.batch_size,
														        self.image_processor_tester.num_channels,
														        expected_height,
														        expected_width,
														    )					,	)






							@slow
							def 			_lowerCamelCase						(  self					):
														# prepare image and target
														UpperCamelCase__			       =     Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
														with open("""./tests/fixtures/tests_samples/COCO/coco_annotations.txt"""					,	"""r"""					) as f:
																					UpperCamelCase__			       =     json.loads(f.read()					)

														UpperCamelCase__			       =     {"""image_id""": 39769, """annotations""": target}

														# encode them
														UpperCamelCase__			       =     DeformableDetrImageProcessor()
														UpperCamelCase__			       =     image_processing(images=__lowerCAmelCase					,	annotations=__lowerCAmelCase					,	return_tensors="""pt"""					)

														# verify pixel values
														UpperCamelCase__			       =     torch.Size([1, 3, 800, 1066]					)
														self.assertEqual(encoding["""pixel_values"""].shape					,	__lowerCAmelCase					)

														UpperCamelCase__			       =     torch.tensor([0.2796, 0.3138, 0.3481]					)
														self.assertTrue(torch.allclose(encoding["""pixel_values"""][0, 0, 0, :3]					,	__lowerCAmelCase					,	atol=1E-4					)					)

														# verify area
														UpperCamelCase__			       =     torch.tensor([5887.9600, 11250.2061, 489353.8438, 837122.7500, 147967.5156, 165732.3438]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""area"""]					,	__lowerCAmelCase					)					)
														# verify boxes
														UpperCamelCase__			       =     torch.Size([6, 4]					)
														self.assertEqual(encoding["""labels"""][0]["""boxes"""].shape					,	__lowerCAmelCase					)
														UpperCamelCase__			       =     torch.tensor([0.5503, 0.2765, 0.0604, 0.2215]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""boxes"""][0]					,	__lowerCAmelCase					,	atol=1E-3					)					)
														# verify image_id
														UpperCamelCase__			       =     torch.tensor([39769]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""image_id"""]					,	__lowerCAmelCase					)					)
														# verify is_crowd
														UpperCamelCase__			       =     torch.tensor([0, 0, 0, 0, 0, 0]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""iscrowd"""]					,	__lowerCAmelCase					)					)
														# verify class_labels
														UpperCamelCase__			       =     torch.tensor([75, 75, 63, 65, 17, 17]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""class_labels"""]					,	__lowerCAmelCase					)					)
														# verify orig_size
														UpperCamelCase__			       =     torch.tensor([480, 640]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""orig_size"""]					,	__lowerCAmelCase					)					)
														# verify size
														UpperCamelCase__			       =     torch.tensor([800, 1066]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""size"""]					,	__lowerCAmelCase					)					)







							@slow
							def 			_lowerCamelCase						(  self					):
														# prepare image, target and masks_path
														UpperCamelCase__			       =     Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
														with open("""./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt"""					,	"""r"""					) as f:
																					UpperCamelCase__			       =     json.loads(f.read()					)

														UpperCamelCase__			       =     {"""file_name""": """000000039769.png""", """image_id""": 39769, """segments_info""": target}

														UpperCamelCase__			       =     pathlib.Path("""./tests/fixtures/tests_samples/COCO/coco_panoptic"""					)

														# encode them
														UpperCamelCase__			       =     DeformableDetrImageProcessor(format="""coco_panoptic"""					)
														UpperCamelCase__			       =     image_processing(images=__lowerCAmelCase					,	annotations=__lowerCAmelCase					,	masks_path=__lowerCAmelCase					,	return_tensors="""pt"""					)

														# verify pixel values
														UpperCamelCase__			       =     torch.Size([1, 3, 800, 1066]					)
														self.assertEqual(encoding["""pixel_values"""].shape					,	__lowerCAmelCase					)

														UpperCamelCase__			       =     torch.tensor([0.2796, 0.3138, 0.3481]					)
														self.assertTrue(torch.allclose(encoding["""pixel_values"""][0, 0, 0, :3]					,	__lowerCAmelCase					,	atol=1E-4					)					)

														# verify area
														UpperCamelCase__			       =     torch.tensor([147979.6875, 165527.0469, 484638.5938, 11292.9375, 5879.6562, 7634.1147]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""area"""]					,	__lowerCAmelCase					)					)
														# verify boxes
														UpperCamelCase__			       =     torch.Size([6, 4]					)
														self.assertEqual(encoding["""labels"""][0]["""boxes"""].shape					,	__lowerCAmelCase					)
														UpperCamelCase__			       =     torch.tensor([0.2625, 0.5437, 0.4688, 0.8625]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""boxes"""][0]					,	__lowerCAmelCase					,	atol=1E-3					)					)
														# verify image_id
														UpperCamelCase__			       =     torch.tensor([39769]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""image_id"""]					,	__lowerCAmelCase					)					)
														# verify is_crowd
														UpperCamelCase__			       =     torch.tensor([0, 0, 0, 0, 0, 0]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""iscrowd"""]					,	__lowerCAmelCase					)					)
														# verify class_labels
														UpperCamelCase__			       =     torch.tensor([17, 17, 63, 75, 75, 93]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""class_labels"""]					,	__lowerCAmelCase					)					)
														# verify masks
														UpperCamelCase__			       =     822873
														self.assertEqual(encoding["""labels"""][0]["""masks"""].sum().item()					,	__lowerCAmelCase					)
														# verify orig_size
														UpperCamelCase__			       =     torch.tensor([480, 640]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""orig_size"""]					,	__lowerCAmelCase					)					)
														# verify size
														UpperCamelCase__			       =     torch.tensor([800, 1066]					)
														self.assertTrue(torch.allclose(encoding["""labels"""][0]["""size"""]					,	__lowerCAmelCase					)					)











import argparse
import dataclasses
import json
import logging
import os
import shutil
from typing import List, Optional

import datasets
from accelerate import Accelerator
from datasets import load_dataset
from finetuning import finetune
from tqdm.auto import tqdm

import transformers
from transformers import AutoConfig, set_seed
from transformers.trainer_utils import IntervalStrategy


UpperCamelCase__     =	logging.getLogger(__name__)

UpperCamelCase__     =	"pytorch_model.bin"

@dataclasses.dataclass
class     __SCREAMING_SNAKE_CASE   :
							snake_case       : str         =    dataclasses.field(
							    metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models."""}    )
							snake_case       : Optional[str]         =    dataclasses.field(
							    default=_a				,						metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co."""}				,						)






@dataclasses.dataclass
class     __SCREAMING_SNAKE_CASE   :
							snake_case       : str         =    dataclasses.field(metadata={"""help""": """A csv or a json file containing the training data."""}    )
							snake_case       : str         =    dataclasses.field(metadata={"""help""": """A csv or a json file containing the data to predict on."""}    )
							snake_case       : Optional[str]         =    dataclasses.field(
							    default=_a				,						metadata={"""help""": """A csv or a json file containing the validation data."""}    )
							snake_case       : Optional[str]         =    dataclasses.field(
							    default=_a				,						metadata={"""help""": """The name of the task to train on."""}				,						)
							snake_case       : Optional[List[str]]         =    dataclasses.field(
							    default=_a				,						metadata={"""help""": """The list of labels for the task."""}    )






@dataclasses.dataclass
class     __SCREAMING_SNAKE_CASE   :
							snake_case       : str         =    dataclasses.field(
							    metadata={"""help""": """The output directory where the model predictions and checkpoints will be written."""}    )
							snake_case       : Optional[str]         =    dataclasses.field(
							    default="""accuracy"""				,						metadata={"""help""": """The evaluation metric used for the task."""}    )
							snake_case       : Optional[str]         =    dataclasses.field(
							    default="""no"""				,						metadata={
							        """help""": """The evaluation strategy to adopt during training. Possible values are: [\"no\", \"step\", \"epoch]"""
							    }				,						)
							snake_case       : Optional[int]         =    dataclasses.field(
							    default=10				,						metadata={"""help""": """Number of evaluation calls with no improvement after which training will be stopped."""}				,						)
							snake_case       : Optional[float]         =    dataclasses.field(
							    default=0.0				,						metadata={
							        """help""": """How much the specified evaluation metric must improve to satisfy early stopping conditions."""
							    }				,						)
							snake_case       : Optional[bool]         =    dataclasses.field(
							    default=_a				,						metadata={"""help""": """Whether to filter the pseudo-labeled data based on the confidence score."""}				,						)
							snake_case       : Optional[bool]         =    dataclasses.field(
							    default=_a				,						metadata={"""help""": """Whether to filter the pseudo-labeled data based on the validation performance."""}				,						)
							snake_case       : Optional[bool]         =    dataclasses.field(
							    default=_a				,						metadata={"""help""": """Whether to fine-tune on labeled data after pseudo training."""}				,						)
							snake_case       : Optional[float]         =    dataclasses.field(
							    default=0.0				,						metadata={"""help""": """Confidence threshold for pseudo-labeled data filtering."""}				,						)
							snake_case       : Optional[int]         =    dataclasses.field(
							    default=1_00				,						metadata={"""help""": """Number of evaluation calls with no improvement after which training will be stopped."""}				,						)
							snake_case       : Optional[int]         =    dataclasses.field(
							    default=_a				,						metadata={"""help""": """Random seed for initialization."""}				,						)






def       _UpperCamelCase       (a__				:List[str]				,     a__				:str				,     a__				:Any				,     a__				:Any				,     a__				:List[str]				,     a__				:Union[str, Any]    ):






							"""simple docstring"""





							UpperCamelCase__			       =     datasets.concatenate_datasets([infer_input, infer_output]				,     axis=1    )

							if args.do_filter_by_confidence:
														UpperCamelCase__			       =     dataset.filter(lambda a__    : example["probability"] > args.confidence_threshold    )

							if args.do_filter_by_val_performance:
														assert eval_result >= 0.0 and eval_result <= 1.0
														UpperCamelCase__			       =     int(eval_result * len(a__    )    )
														print(a__    )
														UpperCamelCase__			       =     dataset.sort("""probability"""				,     reverse=a__    )
														UpperCamelCase__			       =     dataset.select(range(a__    )    )

							UpperCamelCase__			       =     dataset.remove_columns(["""label""", """probability"""]    )
							UpperCamelCase__			       =     dataset.rename_column("""prediction"""				,     """label"""    )
							UpperCamelCase__			       =     dataset.map(lambda a__    : {"label": idalabel[example["label"]]}    )
							UpperCamelCase__			       =     dataset.shuffle(seed=args.seed    )

							UpperCamelCase__			       =     os.path.join(a__				,     f"""train_pseudo.{args.data_file_extension}"""    )
							if args.data_file_extension == "csv":
														dataset.to_csv(a__				,     index=a__    )
							else:
														dataset.to_json(a__    )





def       _UpperCamelCase       (a__				:Union[str, Any]				,     a__				:Any				,     a__				:Optional[int]				,     a__				:Union[str, Any]				,     **a__				:Union[str, Any]    ):






							"""simple docstring"""





							UpperCamelCase__			       =     Accelerator()
							# Make one log on every process with the configuration for debugging.
							logging.basicConfig(
							    format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s"""				,     datefmt="""%m/%d/%Y %H:%M:%S"""				,     level=logging.INFO				,     )
							logger.info(accelerator.state    )

							# Setup logging, we only want one process per machine to log things on the
							# screen. accelerator.is_local_main_process is only True for one process per
							# machine.
							logger.setLevel(logging.INFO if accelerator.is_local_main_process else logging.ERROR    )

							if accelerator.is_local_main_process:
														datasets.utils.logging.set_verbosity_warning()
														transformers.utils.logging.set_verbosity_info()
							else:
														datasets.utils.logging.set_verbosity_error()
														transformers.utils.logging.set_verbosity_error()

							UpperCamelCase__			       =     STModelArguments(model_name_or_path=a__    )
							UpperCamelCase__			       =     STDataArguments(train_file=a__				,     infer_file=a__    )
							UpperCamelCase__			       =     STTrainingArguments(output_dir=a__    )
							UpperCamelCase__			       =     argparse.Namespace()

							for arg_class in (model_args, data_args, training_args):
														for key, value in vars(a__    ).items():
																					setattr(a__				,     a__				,     a__    )

							for key, value in kwargs.items():
														if hasattr(a__				,     a__    ):
																					setattr(a__				,     a__				,     a__    )

    # Sanity checks
							UpperCamelCase__			       =     {}
							UpperCamelCase__			       =     None

							# You need to provide the training data and the data to predict on
							assert args.train_file is not None
							assert args.infer_file is not None
							UpperCamelCase__			       =     args.train_file
							UpperCamelCase__			       =     args.infer_file

							if args.evaluation_strategy != IntervalStrategy.NO.value:
														assert args.eval_file is not None
														UpperCamelCase__			       =     args.eval_file

							for key in data_files:
														UpperCamelCase__			       =     data_files[key].split("""."""    )[-1]
														assert extension in ["csv", "json"], f"""`{key}_file` should be a csv or a json file."""
														if args.data_file_extension is None:
																					UpperCamelCase__			       =     extension
														else:
																					assert extension == args.data_file_extension, f"""`{key}_file` should be a {args.data_file_extension} file`."""

							assert (
							    args.eval_metric in datasets.list_metrics()
							), f"""{args.eval_metric} not in the list of supported metrics {datasets.list_metrics()}."""

							# If passed along, set the training seed now.
							if args.seed is not None:
														set_seed(args.seed    )

							logger.info("""Creating the initial data directory for self-training..."""    )
							UpperCamelCase__			       =     f"""{args.output_dir}/self-train_iter-{{}}""".format
							UpperCamelCase__			       =     data_dir_format(0    )

							if accelerator.is_main_process:
														if args.output_dir is not None:
																					os.makedirs(args.output_dir				,     exist_ok=a__    )
																					os.makedirs(a__				,     exist_ok=a__    )
							accelerator.wait_for_everyone()

							UpperCamelCase__			       =     None
							UpperCamelCase__			       =     None
							UpperCamelCase__			       =     0
							UpperCamelCase__			       =     False
							# Show the progress bar
							UpperCamelCase__			       =     tqdm(range(args.max_selftrain_iterations    )				,     disable=not accelerator.is_local_main_process    )

							# Self-train
							for iteration in range(0				,     int(args.max_selftrain_iterations    )    ):
														UpperCamelCase__			       =     data_dir_format(a__    )
														assert os.path.exists(a__    )

														# Stage 1: initial fine-tuning for iteration = 0 or pseudo-training for
														# iteration > 0
														UpperCamelCase__			       =     os.path.join(a__				,     """stage-1"""    )
														UpperCamelCase__			       =     {
														    """accelerator""": accelerator,
														    """model_name_or_path""": args.model_name_or_path,
														    """cache_dir""": args.cache_dir,
														    """do_train""": True,
														    """train_file""": data_files["""train"""] if iteration == 0 else data_files["""train_pseudo"""],
														    """do_eval""": True if args.eval_file is not None else False,
														    """eval_file""": data_files["""eval"""],
														    """do_predict""": True,
														    """infer_file""": data_files["""infer"""],
														    """task_name""": args.task_name,
														    """label_list""": args.label_list,
														    """output_dir""": current_output_dir,
														    """eval_metric""": args.eval_metric,
														    """evaluation_strategy""": args.evaluation_strategy,
														    """early_stopping_patience""": args.early_stopping_patience,
														    """early_stopping_threshold""": args.early_stopping_threshold,
														    """seed""": args.seed,
														}
														# Add additional training arguments
														for key, value in kwargs.items():
																					if key not in arguments_dict and not hasattr(a__				,     a__    ):
																												arguments_dict.update({key: value}    )

														UpperCamelCase__			       =     os.path.join(a__				,     """best-checkpoint"""				,     a__    )
														if os.path.exists(a__    ):
																					logger.info(
																					    """Found existing model checkpoint at %s. Skipping self-training: iteration: %d, stage: 1."""				,     a__				,     a__				,     )
														else:
																					logger.info("""***** Running self-training: iteration: %d, stage: 1 *****"""				,     a__    )
																					finetune(**a__    )
																					accelerator.wait_for_everyone()
																					assert os.path.exists(a__    )
																					logger.info("""Self-training job completed: iteration: %d, stage: 1."""				,     a__    )

														if iteration > 0 and args.finetune_on_labeled_data:
																					# Stage 2 (optional): fine-tuning on the original labeled data
																					UpperCamelCase__			       =     os.path.join(a__				,     """best-checkpoint"""    )
																					UpperCamelCase__			       =     os.path.join(a__				,     """stage-2"""    )
																					# Update arguments_dict
																					UpperCamelCase__			       =     model_path
																					UpperCamelCase__			       =     data_files["""train"""]
																					UpperCamelCase__			       =     current_output_dir

																					UpperCamelCase__			       =     os.path.join(a__				,     """best-checkpoint"""				,     a__    )
																					if os.path.exists(a__    ):
																												logger.info(
																												    """Found existing model checkpoint at %s. Skipping self-training: iteration: %d, stage: 2."""				,     a__				,     a__				,     )
																					else:
																												logger.info("""***** Running self-training: iteration: %d, stage: 2 *****"""				,     a__    )
																												finetune(**a__    )
																												accelerator.wait_for_everyone()
																												assert os.path.exists(a__    )
																												logger.info("""Self-training job completed: iteration: %d, stage: 2."""				,     a__    )

														UpperCamelCase__			       =     iteration
														UpperCamelCase__			       =     data_dir_format(iteration + 1    )

														UpperCamelCase__			       =     AutoConfig.from_pretrained(os.path.join(a__				,     """best-checkpoint"""    )    )
														UpperCamelCase__			       =     config.idalabel
														UpperCamelCase__			       =     os.path.join(a__				,     """eval_results_best-checkpoint.json"""    )
														UpperCamelCase__			       =     os.path.join(a__				,     """test_results_best-checkpoint.json"""    )
														assert os.path.exists(a__    )

														with open(a__				,     """r"""    ) as f:
																					UpperCamelCase__			       =     float(json.load(a__    )[args.eval_metric]    )
														UpperCamelCase__			       =     os.path.join(a__				,     """infer_output_best-checkpoint.csv"""    )
														assert os.path.exists(a__    )
														# Loading the dataset from local csv or json files.
														UpperCamelCase__			       =     load_dataset(args.data_file_extension				,     data_files={"""data""": data_files["""infer"""]}    )["""data"""]
														UpperCamelCase__			       =     load_dataset("""csv"""				,     data_files={"""data""": infer_output_file}    )["""data"""]

														if accelerator.is_main_process:
																					os.makedirs(a__				,     exist_ok=a__    )
																					shutil.copy(a__				,     os.path.join(a__				,     f"""eval_results_iter-{iteration}.json"""    )    )
																					if os.path.exists(a__    ):
																												shutil.copy(a__				,     os.path.join(a__				,     f"""test_results_iter-{iteration}.json"""    )    )
																					create_pseudo_labeled_data(a__				,     a__				,     a__				,     a__				,     a__				,     a__    )
														accelerator.wait_for_everyone()

														UpperCamelCase__			       =     os.path.join(a__				,     f"""train_pseudo.{args.data_file_extension}"""    )

														if args.evaluation_strategy != IntervalStrategy.NO.value:
																					UpperCamelCase__			       =     eval_result

																					if best_iteration is None:
																												UpperCamelCase__			       =     new_iteration
																												UpperCamelCase__			       =     new_eval_result
																					else:
																												if new_eval_result - best_eval_result > args.early_stopping_threshold:
																																			UpperCamelCase__			       =     new_iteration
																																			UpperCamelCase__			       =     new_eval_result
																																			UpperCamelCase__			       =     0
																												else:
																																			if new_eval_result == best_eval_result:
																																										UpperCamelCase__			       =     new_iteration
																																										UpperCamelCase__			       =     new_eval_result
																																			early_stopping_patience_counter += 1

																												if early_stopping_patience_counter >= args.early_stopping_patience:
																																			UpperCamelCase__			       =     True

														progress_bar.update(1    )

														if should_training_stop:
																					break

							if best_iteration is not None:
														# Save the best iteration
														logger.info("""Best iteration: %d"""				,     a__    )
														logger.info("""Best evaluation result: %s = %f"""				,     args.eval_metric				,     a__    )
														accelerator.wait_for_everyone()
														if accelerator.is_main_process:
																					shutil.copy(
																					    os.path.join(a__				,     f"""eval_results_iter-{iteration}.json"""    )				,     os.path.join(a__				,     """eval_results_best-iteration.json"""    )				,     )
							else:
														# Assume that the last iteration is the best
														logger.info("""Best iteration: %d"""				,     args.max_selftrain_iterations - 1    )
														logger.info("""Best evaluation result: %s = %f"""				,     args.eval_metric				,     a__    )
														accelerator.wait_for_everyone()
														if accelerator.is_main_process:
																					shutil.copy(
																					    os.path.join(a__				,     f"""eval_results_iter-{args.max_selftrain_iterations - 1}.json"""    )				,     os.path.join(a__				,     """eval_results_best-iteration.json"""    )				,     )




