huggingface_setfit.txt

# File: setfit-main/src/setfit/__init__.py
__version__ = '1.1.0.dev0'
import importlib
import os
import warnings
from .data import get_templated_dataset, sample_dataset
from .model_card import SetFitModelCardData
from .modeling import SetFitHead, SetFitModel
from .span import AbsaModel, AbsaTrainer, AspectExtractor, AspectModel, PolarityModel
from .trainer import SetFitTrainer, Trainer
from .trainer_distillation import DistillationSetFitTrainer, DistillationTrainer
from .training_args import TrainingArguments
warnings.filterwarnings('default', category=DeprecationWarning)
if importlib.util.find_spec('codecarbon') and 'CODECARBON_LOG_LEVEL' not in os.environ:
    os.environ['CODECARBON_LOG_LEVEL'] = 'error'

# File: setfit-main/src/setfit/data.py
from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
import pandas as pd
import torch
from datasets import Dataset, DatasetDict, load_dataset
from torch.utils.data import Dataset as TorchDataset
from . import logging
logging.set_verbosity_info()
logger = logging.get_logger(__name__)
if TYPE_CHECKING:
    from transformers import PreTrainedTokenizerBase
TokenizerOutput = Dict[str, List[int]]
SEEDS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
SAMPLE_SIZES = [2, 4, 8, 16, 32, 64]

def get_templated_dataset(dataset: Optional[Dataset]=None, candidate_labels: Optional[List[str]]=None, reference_dataset: Optional[str]=None, template: str='This sentence is {}', sample_size: int=2, text_column: str='text', label_column: str='label', multi_label: bool=False, label_names_column: str='label_text') -> Dataset:
    if dataset is None:
        dataset = Dataset.from_dict({})
    required_columns = {text_column, label_column}
    column_names = set(dataset.column_names)
    if column_names:
        missing_columns = required_columns.difference(column_names)
        if missing_columns:
            raise ValueError(f'The following columns are missing from the input dataset: {missing_columns}.')
    if bool(reference_dataset) == bool(candidate_labels):
        raise ValueError('Must supply exactly one of `reference_dataset` or `candidate_labels` to `get_templated_dataset()`!')
    if candidate_labels is None:
        candidate_labels = get_candidate_labels(reference_dataset, label_names_column)
    empty_label_vector = [0] * len(candidate_labels)
    for (label_id, label_name) in enumerate(candidate_labels):
        label_vector = empty_label_vector.copy()
        label_vector[label_id] = 1
        example = {text_column: template.format(label_name), label_column: label_vector if multi_label else label_id}
        for _ in range(sample_size):
            dataset = dataset.add_item(example)
    return dataset

def get_candidate_labels(dataset_name: str, label_names_column: str='label_text') -> List[str]:
    dataset = load_dataset(dataset_name, split='train')
    try:
        label_features = dataset.features['label']
        candidate_labels = label_features.names
    except AttributeError:
        label_names = dataset.unique(label_names_column)
        label_ids = dataset.unique('label')
        id2label = sorted(zip(label_ids, label_names), key=lambda x: x[0])
        candidate_labels = list(map(lambda x: x[1], id2label))
    return candidate_labels

def create_samples(df: pd.DataFrame, sample_size: int, seed: int) -> pd.DataFrame:
    examples = []
    for label in df['label'].unique():
        subset = df.query(f'label == {label}')
        if len(subset) > sample_size:
            examples.append(subset.sample(sample_size, random_state=seed, replace=False))
        else:
            examples.append(subset)
    return pd.concat(examples)

def sample_dataset(dataset: Dataset, label_column: str='label', num_samples: int=8, seed: int=42) -> Dataset:
    shuffled_dataset = dataset.shuffle(seed=seed)
    df = shuffled_dataset.to_pandas()
    df = df.groupby(label_column)
    df = df.apply(lambda x: x.sample(min(num_samples, len(x)), random_state=seed))
    df = df.reset_index(drop=True)
    all_samples = Dataset.from_pandas(df, features=dataset.features)
    return all_samples.shuffle(seed=seed)

def create_fewshot_splits(dataset: Dataset, sample_sizes: List[int], add_data_augmentation: bool=False, dataset_name: Optional[str]=None) -> DatasetDict:
    splits_ds = DatasetDict()
    df = dataset.to_pandas()
    if add_data_augmentation and dataset_name is None:
        raise ValueError('If `add_data_augmentation` is True, must supply a `dataset_name` to create_fewshot_splits()!')
    for sample_size in sample_sizes:
        if add_data_augmentation:
            augmented_df = get_templated_dataset(reference_dataset=dataset_name, sample_size=sample_size).to_pandas()
        for (idx, seed) in enumerate(SEEDS):
            split_df = create_samples(df, sample_size, seed)
            if add_data_augmentation:
                split_df = pd.concat([split_df, augmented_df], axis=0).sample(frac=1, random_state=seed)
            splits_ds[f'train-{sample_size}-{idx}'] = Dataset.from_pandas(split_df, preserve_index=False)
    return splits_ds

def create_samples_multilabel(df: pd.DataFrame, sample_size: int, seed: int) -> pd.DataFrame:
    examples = []
    column_labels = [_col for _col in df.columns.tolist() if _col != 'text']
    for label in column_labels:
        subset = df.query(f'{label} == 1')
        if len(subset) > sample_size:
            examples.append(subset.sample(sample_size, random_state=seed, replace=False))
        else:
            examples.append(subset)
    return pd.concat(examples).drop_duplicates()

def create_fewshot_splits_multilabel(dataset: Dataset, sample_sizes: List[int]) -> DatasetDict:
    splits_ds = DatasetDict()
    df = dataset.to_pandas()
    for sample_size in sample_sizes:
        for (idx, seed) in enumerate(SEEDS):
            split_df = create_samples_multilabel(df, sample_size, seed)
            splits_ds[f'train-{sample_size}-{idx}'] = Dataset.from_pandas(split_df, preserve_index=False)
    return splits_ds

class SetFitDataset(TorchDataset):

    def __init__(self, x: List[str], y: Union[List[int], List[List[int]]], tokenizer: 'PreTrainedTokenizerBase', max_length: int=32) -> None:
        assert len(x) == len(y)
        self.x = x
        self.y = y
        self.tokenizer = tokenizer
        self.max_length = max_length

    def __len__(self) -> int:
        return len(self.x)

    def __getitem__(self, idx: int) -> Tuple[TokenizerOutput, Union[int, List[int]]]:
        feature = self.tokenizer(self.x[idx], max_length=self.max_length, padding='max_length', truncation=True, return_attention_mask='attention_mask' in self.tokenizer.model_input_names, return_token_type_ids='token_type_ids' in self.tokenizer.model_input_names)
        label = self.y[idx]
        return (feature, label)

    def collate_fn(self, batch):
        features = {input_name: [] for input_name in self.tokenizer.model_input_names}
        labels = []
        for (feature, label) in batch:
            features['input_ids'].append(feature['input_ids'])
            if 'attention_mask' in features:
                features['attention_mask'].append(feature['attention_mask'])
            if 'token_type_ids' in features:
                features['token_type_ids'].append(feature['token_type_ids'])
            labels.append(label)
        features = {k: torch.Tensor(v).int() for (k, v) in features.items()}
        labels = torch.Tensor(labels)
        labels = labels.long() if len(labels.size()) == 1 else labels.float()
        return (features, labels)

# File: setfit-main/src/setfit/exporters/onnx.py
import copy
import warnings
from typing import Callable, Optional, Union
import numpy as np
import onnx
import torch
from sentence_transformers import SentenceTransformer, models
from sklearn.linear_model import LogisticRegression
from transformers.modeling_utils import PreTrainedModel
from setfit.exporters.utils import mean_pooling

class OnnxSetFitModel(torch.nn.Module):

    def __init__(self, model_body: PreTrainedModel, pooler: Optional[Union[torch.nn.Module, Callable[[torch.Tensor], torch.Tensor]]]=None, model_head: Optional[Union[torch.nn.Module, LogisticRegression]]=None):
        super().__init__()
        self.model_body = model_body
        if pooler is None:
            print('No pooler was set so defaulting to mean pooling.')
            self.pooler = mean_pooling
        else:
            self.pooler = pooler
        self.model_head = model_head

    def forward(self, input_ids: torch.Tensor, attention_mask: torch.Tensor, token_type_ids: torch.Tensor):
        hidden_states = self.model_body(input_ids, attention_mask, token_type_ids)
        hidden_states = {'token_embeddings': hidden_states[0], 'attention_mask': attention_mask}
        embeddings = self.pooler(hidden_states)
        if self.model_head is None:
            return embeddings
        out = self.model_head(embeddings)
        return out

def export_onnx_setfit_model(setfit_model: OnnxSetFitModel, inputs, output_path, opset: int=12):
    input_names = list(inputs.keys())
    output_names = ['logits']
    dynamic_axes_input = {}
    for input_name in input_names:
        dynamic_axes_input[input_name] = {0: 'batch_size', 1: 'sequence'}
    dynamic_axes_output = {}
    for output_name in output_names:
        dynamic_axes_output[output_name] = {0: 'batch_size'}
    target = setfit_model.model_body.device
    args = tuple((value.to(target) for value in inputs.values()))
    setfit_model.eval()
    with torch.no_grad():
        torch.onnx.export(setfit_model, args=args, f=output_path, opset_version=opset, input_names=['input_ids', 'attention_mask', 'token_type_ids'], output_names=output_names, dynamic_axes={**dynamic_axes_input, **dynamic_axes_output})

def export_sklearn_head_to_onnx(model_head: LogisticRegression, opset: int) -> onnx.onnx_ml_pb2.ModelProto:
    try:
        import onnxconverter_common
        from skl2onnx import convert_sklearn
        from skl2onnx.common.data_types import guess_data_type
        from skl2onnx.sklapi import CastTransformer
        from sklearn.pipeline import Pipeline
    except ImportError:
        msg = '\n        `skl2onnx` must be installed in order to convert a model with an sklearn head.\n        Please install with `pip install skl2onnx`.\n        '
        raise ImportError(msg)
    input_shape = (None, model_head.n_features_in_)
    if hasattr(model_head, 'coef_'):
        dtype = guess_data_type(model_head.coef_, shape=input_shape)[0][1]
    elif not hasattr(model_head, 'coef_') and hasattr(model_head, 'estimators_'):
        if any([not hasattr(e, 'coef_') for e in model_head.estimators_]):
            raise ValueError('The model_head is a meta-estimator but not all of the estimators have a coef_ attribute.')
        dtype = guess_data_type(model_head.estimators_[0].coef_, shape=input_shape)[0][1]
    else:
        raise ValueError('The model_head either does not have a coef_ attribute or some estimators in model_head.estimators_ do not have a coef_ attribute. Conversion to ONNX only supports these cases.')
    dtype.shape = input_shape
    if isinstance(dtype, onnxconverter_common.data_types.DoubleTensorType):
        sklearn_model = Pipeline([('castdouble', CastTransformer(dtype=np.double)), ('head', model_head)])
    else:
        sklearn_model = model_head
    onnx_model = convert_sklearn(sklearn_model, initial_types=[('model_head', dtype)], target_opset=opset, options={id(sklearn_model): {'zipmap': False}})
    return onnx_model

def hummingbird_export(model, data_sample):
    try:
        from hummingbird.ml import convert
    except ImportError:
        raise ImportError("Hummingbird-ML library is not installed.Run 'pip install hummingbird-ml' to use this type of export.")
    onnx_model = convert(model, 'onnx', data_sample)
    return onnx_model._model

def export_onnx(model_body: SentenceTransformer, model_head: Union[torch.nn.Module, LogisticRegression], opset: int, output_path: str='model.onnx', ignore_ir_version: bool=True, use_hummingbird: bool=False) -> None:
    model_body_module = model_body._modules['0']
    model_pooler = model_body._modules['1']
    tokenizer = model_body_module.tokenizer
    max_length = model_body_module.max_seq_length
    transformer = model_body_module.auto_model
    transformer.eval()
    tokenizer_kwargs = dict(max_length=max_length, padding='max_length', return_attention_mask=True, return_token_type_ids=True, return_tensors='pt')
    dummy_sample = "It's a test."
    dummy_inputs = tokenizer(dummy_sample, **tokenizer_kwargs)
    if issubclass(type(model_head), models.Dense):
        setfit_model = OnnxSetFitModel(transformer, lambda x: model_pooler(x)['sentence_embedding'], model_head).cpu()
        export_onnx_setfit_model(setfit_model, dummy_inputs, output_path, opset)
        onnx_setfit_model = onnx.load(output_path)
        meta = onnx_setfit_model.metadata_props.add()
        for (key, value) in tokenizer_kwargs.items():
            meta = onnx_setfit_model.metadata_props.add()
            meta.key = str(key)
            meta.value = str(value)
    else:
        if use_hummingbird:
            with torch.no_grad():
                test_input = copy.deepcopy(dummy_inputs)
                head_input = model_body(test_input)['sentence_embedding']
                onnx_head = hummingbird_export(model_head, head_input.detach().numpy())
        else:
            onnx_head = export_sklearn_head_to_onnx(model_head, opset)
        max_opset = max([x.version for x in onnx_head.opset_import])
        if max_opset != opset:
            warnings.warn(f'sklearn onnx max opset is {max_opset} requested opset {opset} using opset {max_opset} for compatibility.')
        export_onnx_setfit_model(OnnxSetFitModel(transformer, lambda x: model_pooler(x)['sentence_embedding']), dummy_inputs, output_path, max_opset)
        onnx_body = onnx.load(output_path)
        if ignore_ir_version:
            onnx_head.ir_version = onnx_body.ir_version
        elif onnx_head.ir_version != onnx_body.ir_version:
            msg = f'\n            IR Version mismatch between head={onnx_head.ir_version} and body={onnx_body.ir_version}\n            Make sure that the ONNX IR versions are aligned and supported between the chosen Sklearn model\n            and the transformer.  You can set ignore_ir_version=True to coerce them but this might cause errors.\n            '
            raise ValueError(msg)
        head_input_name = next(iter(onnx_head.graph.input)).name
        onnx_setfit_model = onnx.compose.merge_models(onnx_body, onnx_head, io_map=[('logits', head_input_name)])
    onnx.save(onnx_setfit_model, output_path)

# File: setfit-main/src/setfit/exporters/openvino.py
import os
import openvino.runtime as ov
from setfit import SetFitModel
from setfit.exporters.onnx import export_onnx

def export_to_openvino(model: SetFitModel, output_path: str='model.xml') -> None:
    OPENVINO_SUPPORTED_OPSET = 13
    model.model_body.cpu()
    onnx_path = output_path.replace('.xml', '.onnx')
    export_onnx(model.model_body, model.model_head, opset=OPENVINO_SUPPORTED_OPSET, output_path=onnx_path, ignore_ir_version=True, use_hummingbird=True)
    ov_model = ov.Core().read_model(onnx_path)
    ov.serialize(ov_model, output_path)
    os.remove(onnx_path)

# File: setfit-main/src/setfit/exporters/utils.py
import torch

def mean_pooling(token_embeddings: torch.Tensor, attention_mask: torch.Tensor) -> torch.Tensor:
    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-09)

# File: setfit-main/src/setfit/integrations.py
import importlib.util
from typing import TYPE_CHECKING
from .utils import BestRun
if TYPE_CHECKING:
    from .trainer import Trainer

def is_optuna_available() -> bool:
    return importlib.util.find_spec('optuna') is not None

def default_hp_search_backend():
    if is_optuna_available():
        return 'optuna'

def run_hp_search_optuna(trainer: 'Trainer', n_trials: int, direction: str, **kwargs) -> BestRun:
    import optuna

    def _objective(trial):
        trainer.objective = None
        trainer.train(trial=trial)
        if getattr(trainer, 'objective', None) is None:
            metrics = trainer.evaluate()
            trainer.objective = trainer.compute_objective(metrics)
        return trainer.objective
    timeout = kwargs.pop('timeout', None)
    n_jobs = kwargs.pop('n_jobs', 1)
    study = optuna.create_study(direction=direction, **kwargs)
    study.optimize(_objective, n_trials=n_trials, timeout=timeout, n_jobs=n_jobs)
    best_trial = study.best_trial
    return BestRun(str(best_trial.number), best_trial.value, best_trial.params, study)

# File: setfit-main/src/setfit/logging.py
""""""
import logging
import os
import sys
import threading
from logging import CRITICAL
from logging import DEBUG
from logging import ERROR
from logging import FATAL
from logging import INFO
from logging import NOTSET
from logging import WARN
from logging import WARNING
from typing import Optional
import huggingface_hub.utils as hf_hub_utils
from tqdm import auto as tqdm_lib
_lock = threading.Lock()
_default_handler: Optional[logging.Handler] = None
log_levels = {'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR, 'critical': logging.CRITICAL}
_default_log_level = logging.WARNING
_tqdm_active = True

def _get_default_logging_level():
    env_level_str = os.getenv('TRANSFORMERS_VERBOSITY', None)
    if env_level_str:
        if env_level_str in log_levels:
            return log_levels[env_level_str]
        else:
            logging.getLogger().warning(f"Unknown option TRANSFORMERS_VERBOSITY={env_level_str}, has to be one of: {', '.join(log_levels.keys())}")
    return _default_log_level

def _get_library_name() -> str:
    return __name__.split('.')[0]

def _get_library_root_logger() -> logging.Logger:
    return logging.getLogger(_get_library_name())

def _configure_library_root_logger() -> None:
    global _default_handler
    with _lock:
        if _default_handler:
            return
        _default_handler = logging.StreamHandler()
        _default_handler.flush = sys.stderr.flush
        library_root_logger = _get_library_root_logger()
        library_root_logger.addHandler(_default_handler)
        library_root_logger.setLevel(_get_default_logging_level())
        library_root_logger.propagate = False

def _reset_library_root_logger() -> None:
    global _default_handler
    with _lock:
        if not _default_handler:
            return
        library_root_logger = _get_library_root_logger()
        library_root_logger.removeHandler(_default_handler)
        library_root_logger.setLevel(logging.NOTSET)
        _default_handler = None

def get_log_levels_dict():
    return log_levels

def get_logger(name: Optional[str]=None) -> logging.Logger:
    if name is None:
        name = _get_library_name()
    _configure_library_root_logger()
    return logging.getLogger(name)

def get_verbosity() -> int:
    _configure_library_root_logger()
    return _get_library_root_logger().getEffectiveLevel()

def set_verbosity(verbosity: int) -> None:
    _configure_library_root_logger()
    _get_library_root_logger().setLevel(verbosity)

def set_verbosity_info():
    return set_verbosity(INFO)

def set_verbosity_warning():
    return set_verbosity(WARNING)

def set_verbosity_debug():
    return set_verbosity(DEBUG)

def set_verbosity_error():
    return set_verbosity(ERROR)

def disable_default_handler() -> None:
    _configure_library_root_logger()
    assert _default_handler is not None
    _get_library_root_logger().removeHandler(_default_handler)

def enable_default_handler() -> None:
    _configure_library_root_logger()
    assert _default_handler is not None
    _get_library_root_logger().addHandler(_default_handler)

def add_handler(handler: logging.Handler) -> None:
    _configure_library_root_logger()
    assert handler is not None
    _get_library_root_logger().addHandler(handler)

def remove_handler(handler: logging.Handler) -> None:
    _configure_library_root_logger()
    assert handler is not None and handler not in _get_library_root_logger().handlers
    _get_library_root_logger().removeHandler(handler)

def disable_propagation() -> None:
    _configure_library_root_logger()
    _get_library_root_logger().propagate = False

def enable_propagation() -> None:
    _configure_library_root_logger()
    _get_library_root_logger().propagate = True

def enable_explicit_format() -> None:
    handlers = _get_library_root_logger().handlers
    for handler in handlers:
        formatter = logging.Formatter('[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s')
        handler.setFormatter(formatter)

def reset_format() -> None:
    handlers = _get_library_root_logger().handlers
    for handler in handlers:
        handler.setFormatter(None)

def warning_advice(self, *args, **kwargs):
    no_advisory_warnings = os.getenv('TRANSFORMERS_NO_ADVISORY_WARNINGS', False)
    if no_advisory_warnings:
        return
    self.warning(*args, **kwargs)
logging.Logger.warning_advice = warning_advice

class EmptyTqdm:

    def __init__(self, *args, **kwargs):
        self._iterator = args[0] if args else None

    def __iter__(self):
        return iter(self._iterator)

    def __getattr__(self, _):

        def empty_fn(*args, **kwargs):
            return
        return empty_fn

    def __enter__(self):
        return self

    def __exit__(self, type_, value, traceback):
        return

class _tqdm_cls:

    def __call__(self, *args, **kwargs):
        if _tqdm_active:
            return tqdm_lib.tqdm(*args, **kwargs)
        else:
            return EmptyTqdm(*args, **kwargs)

    def set_lock(self, *args, **kwargs):
        self._lock = None
        if _tqdm_active:
            return tqdm_lib.tqdm.set_lock(*args, **kwargs)

    def get_lock(self):
        if _tqdm_active:
            return tqdm_lib.tqdm.get_lock()
tqdm = _tqdm_cls()

def is_progress_bar_enabled() -> bool:
    global _tqdm_active
    return bool(_tqdm_active)

def enable_progress_bar():
    global _tqdm_active
    _tqdm_active = True
    hf_hub_utils.enable_progress_bars()

def disable_progress_bar():
    global _tqdm_active
    _tqdm_active = False
    hf_hub_utils.disable_progress_bars()

# File: setfit-main/src/setfit/losses.py
import torch
from torch import nn

class SupConLoss(nn.Module):

    def __init__(self, model, temperature=0.07, contrast_mode='all', base_temperature=0.07):
        super(SupConLoss, self).__init__()
        self.model = model
        self.temperature = temperature
        self.contrast_mode = contrast_mode
        self.base_temperature = base_temperature

    def forward(self, sentence_features, labels=None, mask=None):
        features = self.model(sentence_features[0])['sentence_embedding']
        features = torch.nn.functional.normalize(features, p=2, dim=1)
        features = torch.unsqueeze(features, 1)
        device = features.device
        if len(features.shape) < 3:
            raise ValueError('`features` needs to be [bsz, n_views, ...],at least 3 dimensions are required')
        if len(features.shape) > 3:
            features = features.view(features.shape[0], features.shape[1], -1)
        batch_size = features.shape[0]
        if labels is not None and mask is not None:
            raise ValueError('Cannot define both `labels` and `mask`')
        elif labels is None and mask is None:
            mask = torch.eye(batch_size, dtype=torch.float32).to(device)
        elif labels is not None:
            labels = labels.contiguous().view(-1, 1)
            if labels.shape[0] != batch_size:
                raise ValueError('Num of labels does not match num of features')
            mask = torch.eq(labels, labels.T).float().to(device)
        else:
            mask = mask.float().to(device)
        contrast_count = features.shape[1]
        contrast_feature = torch.cat(torch.unbind(features, dim=1), dim=0)
        if self.contrast_mode == 'one':
            anchor_feature = features[:, 0]
            anchor_count = 1
        elif self.contrast_mode == 'all':
            anchor_feature = contrast_feature
            anchor_count = contrast_count
        else:
            raise ValueError('Unknown mode: {}'.format(self.contrast_mode))
        anchor_dot_contrast = torch.div(torch.matmul(anchor_feature, contrast_feature.T), self.temperature)
        (logits_max, _) = torch.max(anchor_dot_contrast, dim=1, keepdim=True)
        logits = anchor_dot_contrast - logits_max.detach()
        mask = mask.repeat(anchor_count, contrast_count)
        logits_mask = torch.scatter(torch.ones_like(mask), 1, torch.arange(batch_size * anchor_count).view(-1, 1).to(device), 0)
        mask = mask * logits_mask
        exp_logits = torch.exp(logits) * logits_mask
        log_prob = logits - torch.log(exp_logits.sum(1, keepdim=True))
        mean_log_prob_pos = (mask * log_prob).sum(1) / mask.sum(1)
        loss = -(self.temperature / self.base_temperature) * mean_log_prob_pos
        loss = loss.view(anchor_count, batch_size).mean()
        return loss

# File: setfit-main/src/setfit/model_card.py
import collections
import random
from collections import Counter, defaultdict
from dataclasses import dataclass, field, fields
from pathlib import Path
from platform import python_version
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
import datasets
import tokenizers
import torch
import transformers
from datasets import Dataset
from huggingface_hub import CardData, ModelCard, dataset_info, list_datasets, model_info
from huggingface_hub.repocard_data import EvalResult, eval_results_to_model_index
from huggingface_hub.utils import yaml_dump
from sentence_transformers import __version__ as sentence_transformers_version
from transformers import PretrainedConfig, TrainerCallback
from transformers.integrations import CodeCarbonCallback
from transformers.modelcard import make_markdown_table
from transformers.trainer_callback import TrainerControl, TrainerState
from transformers.training_args import TrainingArguments
from setfit import __version__ as setfit_version
from . import logging
logger = logging.get_logger(__name__)
if TYPE_CHECKING:
    from setfit.modeling import SetFitModel
    from setfit.trainer import Trainer

class ModelCardCallback(TrainerCallback):

    def __init__(self, trainer: 'Trainer') -> None:
        super().__init__()
        self.trainer = trainer
        callbacks = [callback for callback in self.trainer.callback_handler.callbacks if isinstance(callback, CodeCarbonCallback)]
        if callbacks:
            trainer.model.model_card_data.code_carbon_callback = callbacks[0]

    def on_init_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, model: 'SetFitModel', **kwargs):
        if not model.model_card_data.dataset_id:
            try:
                model.model_card_data.infer_dataset_id(self.trainer.train_dataset)
            except Exception:
                pass
        dataset = self.trainer.eval_dataset or self.trainer.train_dataset
        if dataset is not None:
            if not model.model_card_data.widget:
                model.model_card_data.set_widget_examples(dataset)
        if self.trainer.train_dataset:
            model.model_card_data.set_train_set_metrics(self.trainer.train_dataset)
            try:
                model.model_card_data.num_classes = len(set(self.trainer.train_dataset['label']))
                model.model_card_data.set_label_examples(self.trainer.train_dataset)
            except Exception:
                pass

    def on_train_begin(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, model: 'SetFitModel', **kwargs) -> None:
        ignore_keys = {'output_dir', 'logging_dir', 'logging_strategy', 'logging_first_step', 'logging_steps', 'eval_strategy', 'eval_steps', 'eval_delay', 'save_strategy', 'save_steps', 'save_total_limit', 'metric_for_best_model', 'greater_is_better', 'report_to', 'samples_per_label', 'show_progress_bar'}
        get_name_keys = {'loss', 'distance_metric'}
        args_dict = args.to_dict()
        model.model_card_data.hyperparameters = {key: value.__name__ if key in get_name_keys else value for (key, value) in args_dict.items() if key not in ignore_keys and value is not None}

    def on_evaluate(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, model: 'SetFitModel', metrics: Dict[str, float], **kwargs) -> None:
        if model.model_card_data.eval_lines_list and model.model_card_data.eval_lines_list[-1]['Step'] == state.global_step:
            model.model_card_data.eval_lines_list[-1]['Validation Loss'] = metrics['eval_embedding_loss']
        else:
            model.model_card_data.eval_lines_list.append({'Epoch': state.epoch, 'Step': state.global_step, 'Training Loss': '-', 'Validation Loss': metrics['eval_embedding_loss']})

    def on_log(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, model: 'SetFitModel', logs: Dict[str, float], **kwargs):
        keys = {'embedding_loss', 'polarity_embedding_loss', 'aspect_embedding_loss'} & set(logs)
        if keys:
            if model.model_card_data.eval_lines_list and model.model_card_data.eval_lines_list[-1]['Step'] == state.global_step:
                model.model_card_data.eval_lines_list[-1]['Training Loss'] = logs[keys.pop()]
            else:
                model.model_card_data.eval_lines_list.append({'Epoch': state.epoch, 'Step': state.global_step, 'Training Loss': logs[keys.pop()], 'Validation Loss': '-'})
YAML_FIELDS = ['language', 'license', 'library_name', 'tags', 'datasets', 'metrics', 'pipeline_tag', 'widget', 'model-index', 'co2_eq_emissions', 'base_model', 'inference']
IGNORED_FIELDS = ['model']

@dataclass
class SetFitModelCardData(CardData):
    language: Optional[Union[str, List[str]]] = None
    license: Optional[str] = None
    tags: Optional[List[str]] = field(default_factory=lambda : ['setfit', 'sentence-transformers', 'text-classification', 'generated_from_setfit_trainer'])
    model_name: Optional[str] = None
    model_id: Optional[str] = None
    dataset_name: Optional[str] = None
    dataset_id: Optional[str] = None
    dataset_revision: Optional[str] = None
    task_name: Optional[str] = None
    st_id: Optional[str] = None
    hyperparameters: Dict[str, Any] = field(default_factory=dict, init=False)
    eval_results_dict: Optional[Dict[str, Any]] = field(default_factory=dict, init=False)
    eval_lines_list: List[Dict[str, float]] = field(default_factory=list, init=False)
    metric_lines: List[Dict[str, float]] = field(default_factory=list, init=False)
    widget: List[Dict[str, str]] = field(default_factory=list, init=False)
    predict_example: Optional[str] = field(default=None, init=False)
    label_example_list: List[Dict[str, str]] = field(default_factory=list, init=False)
    tokenizer_warning: bool = field(default=False, init=False)
    train_set_metrics_list: List[Dict[str, str]] = field(default_factory=list, init=False)
    train_set_sentences_per_label_list: List[Dict[str, str]] = field(default_factory=list, init=False)
    code_carbon_callback: Optional[CodeCarbonCallback] = field(default=None, init=False)
    num_classes: Optional[int] = field(default=None, init=False)
    best_model_step: Optional[int] = field(default=None, init=False)
    metrics: List[str] = field(default_factory=lambda : ['accuracy'], init=False)
    pipeline_tag: str = field(default='text-classification', init=False)
    library_name: str = field(default='setfit', init=False)
    version: Dict[str, str] = field(default_factory=lambda : {'python': python_version(), 'setfit': setfit_version, 'sentence_transformers': sentence_transformers_version, 'transformers': transformers.__version__, 'torch': torch.__version__, 'datasets': datasets.__version__, 'tokenizers': tokenizers.__version__}, init=False)
    absa: Dict[str, Any] = field(default=None, init=False, repr=False)
    model: Optional['SetFitModel'] = field(default=None, init=False, repr=False)
    head_class: Optional[str] = field(default=None, init=False, repr=False)
    inference: Optional[bool] = field(default=True, init=False, repr=False)

    def __post_init__(self):
        if self.dataset_id:
            if is_on_huggingface(self.dataset_id, is_model=False):
                if self.language is None:
                    try:
                        info = dataset_info(self.dataset_id)
                    except Exception:
                        pass
                    else:
                        if info.cardData:
                            self.language = info.cardData.get('language', self.language)
            else:
                logger.warning(f'The provided {self.dataset_id!r} dataset could not be found on the Hugging Face Hub. Setting `dataset_id` to None.')
                self.dataset_id = None
        if self.model_id and self.model_id.count('/') != 1:
            logger.warning(f'The provided {self.model_id!r} model ID should include the organization or user, such as "tomaarsen/setfit-bge-small-v1.5-sst2-8-shot". Setting `model_id` to None.')
            self.model_id = None

    def set_best_model_step(self, step: int) -> None:
        self.best_model_step = step

    def set_widget_examples(self, dataset: Dataset) -> None:
        samples = dataset.select(random.sample(range(len(dataset)), k=min(len(dataset), 5)))['text']
        self.widget = [{'text': sample} for sample in samples]
        samples.sort(key=len)
        if samples:
            self.predict_example = samples[0]

    def set_train_set_metrics(self, dataset: Dataset) -> None:

        def add_naive_word_count(sample: Dict[str, Any]) -> Dict[str, Any]:
            sample['word_count'] = len(sample['text'].split(' '))
            return sample
        dataset = dataset.map(add_naive_word_count)
        self.train_set_metrics_list = [{'Training set': 'Word count', 'Min': min(dataset['word_count']), 'Median': sum(dataset['word_count']) / len(dataset), 'Max': max(dataset['word_count'])}]
        if 'label' not in dataset.column_names:
            return
        sample_label = dataset[0]['label']
        if isinstance(sample_label, collections.abc.Sequence) and (not isinstance(sample_label, str)):
            return
        try:
            counter = Counter(dataset['label'])
            if self.model.labels:
                self.train_set_sentences_per_label_list = [{'Label': str_label, 'Training Sample Count': counter[str_label if isinstance(sample_label, str) else self.model.label2id[str_label]]} for str_label in self.model.labels]
            else:
                self.train_set_sentences_per_label_list = [{'Label': self.model.labels[label] if self.model.labels and isinstance(label, int) else str(label), 'Training Sample Count': count} for (label, count) in sorted(counter.items())]
        except Exception:
            pass

    def set_label_examples(self, dataset: Dataset) -> None:
        num_examples_per_label = 3
        examples = defaultdict(list)
        finished_labels = set()
        for sample in dataset:
            text = sample['text']
            label = sample['label']
            if label not in finished_labels:
                examples[label].append(f'<li>{repr(text)}</li>')
                if len(examples[label]) >= num_examples_per_label:
                    finished_labels.add(label)
            if len(finished_labels) == self.num_classes:
                break
        self.label_example_list = [{'Label': self.model.labels[label] if self.model.labels and isinstance(label, int) else label, 'Examples': '<ul>' + ''.join(example_set) + '</ul>'} for (label, example_set) in examples.items()]

    def infer_dataset_id(self, dataset: Dataset) -> None:

        def subtuple_finder(tuple: Tuple[str], subtuple: Tuple[str]) -> int:
            for (i, element) in enumerate(tuple):
                if element == subtuple[0] and tuple[i:i + len(subtuple)] == subtuple:
                    return i
            return -1

        def normalize(dataset_id: str) -> str:
            for token in '/\\_-':
                dataset_id = dataset_id.replace(token, '')
            return dataset_id.lower()
        cache_files = dataset.cache_files
        if cache_files and 'filename' in cache_files[0]:
            cache_path_parts = Path(cache_files[0]['filename']).parts
            subtuple = ('huggingface', 'datasets')
            index = subtuple_finder(cache_path_parts, subtuple)
            if index == -1:
                return
            cache_dataset_name = cache_path_parts[index + len(subtuple)]
            if '___' in cache_dataset_name:
                (author, dataset_name) = cache_dataset_name.split('___')
            else:
                author = None
                dataset_name = cache_dataset_name
            dataset_list = [dataset for dataset in list_datasets(author=author, dataset_name=dataset_name) if normalize(dataset.id) == normalize(cache_dataset_name)]
            if len(dataset_list) == 1:
                self.dataset_id = dataset_list[0].id

    def register_model(self, model: 'SetFitModel') -> None:
        self.model = model
        head_class = model.model_head.__class__.__name__
        self.head_class = {'LogisticRegression': '[LogisticRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html)', 'SetFitHead': '[SetFitHead](huggingface.co/docs/setfit/reference/main#setfit.SetFitHead)'}.get(head_class, head_class)
        if not self.model_name:
            if self.st_id:
                self.model_name = f'SetFit with {self.st_id}'
                if self.dataset_name or self.dataset_id:
                    self.model_name += f' on {self.dataset_name or self.dataset_id}'
            else:
                self.model_name = 'SetFit'
        self.inference = self.model.multi_target_strategy is None

    def infer_st_id(self, setfit_model_id: str) -> None:
        (config_dict, _) = PretrainedConfig.get_config_dict(setfit_model_id)
        st_id = config_dict.get('_name_or_path')
        st_id_path = Path(st_id)
        candidate_model_ids = ['/'.join(st_id_path.parts[-2:])]
        splits = st_id_path.name.split('_')
        candidate_model_ids += ['_'.join(splits[:idx]) + '/' + '_'.join(splits[idx:]) for idx in range(1, len(splits))]
        for model_id in candidate_model_ids:
            if is_on_huggingface(model_id):
                self.st_id = model_id
                break

    def set_st_id(self, model_id: str) -> None:
        if is_on_huggingface(model_id):
            self.st_id = model_id

    def post_training_eval_results(self, results: Dict[str, float]) -> None:

        def try_to_pure_python(value: Any) -> Any:
            try:
                if hasattr(value, 'dtype'):
                    return value.item()
            except Exception:
                pass
            return value
        pure_python_results = {key: try_to_pure_python(value) for (key, value) in results.items()}
        results_without_split = {key.split('_', maxsplit=1)[1].title(): value for (key, value) in pure_python_results.items()}
        self.eval_results_dict = pure_python_results
        self.metric_lines = [{'Label': '**all**', **results_without_split}]

    def _maybe_round(self, v, decimals=4):
        if isinstance(v, float) and len(str(v).split('.')) > 1 and (len(str(v).split('.')[1]) > decimals):
            return f'{v:.{decimals}f}'
        return str(v)

    def to_dict(self) -> Dict[str, Any]:
        super_dict = {field.name: getattr(self, field.name) for field in fields(self)}
        if self.eval_results_dict:
            dataset_split = list(self.eval_results_dict.keys())[0].split('_')[0]
            dataset_id = self.dataset_id or 'unknown'
            dataset_name = self.dataset_name or self.dataset_id or 'Unknown'
            eval_results = [EvalResult(task_type='text-classification', dataset_type=dataset_id, dataset_name=dataset_name, dataset_split=dataset_split, dataset_revision=self.dataset_revision, metric_type=metric_key.split('_', maxsplit=1)[1], metric_value=metric_value, task_name='Text Classification', metric_name=metric_key.split('_', maxsplit=1)[1].title()) for (metric_key, metric_value) in self.eval_results_dict.items()]
            super_dict['metrics'] = [metric_key.split('_', maxsplit=1)[1] for metric_key in self.eval_results_dict]
            super_dict['model-index'] = eval_results_to_model_index(self.model_name, eval_results)
        eval_lines_list = [{key: f'**{self._maybe_round(value)}**' if line['Step'] == self.best_model_step else value for (key, value) in line.items()} for line in self.eval_lines_list]
        super_dict['eval_lines'] = make_markdown_table(eval_lines_list)
        super_dict['explain_bold_in_eval'] = '**' in super_dict['eval_lines']
        super_dict['label_examples'] = make_markdown_table(self.label_example_list).replace('-:|', '--|')
        super_dict['train_set_metrics'] = make_markdown_table(self.train_set_metrics_list).replace('-:|', '--|')
        super_dict['train_set_sentences_per_label_list'] = make_markdown_table(self.train_set_sentences_per_label_list).replace('-:|', '--|')
        super_dict['metrics_table'] = make_markdown_table(self.metric_lines).replace('-:|', '--|')
        if self.code_carbon_callback and self.code_carbon_callback.tracker:
            emissions_data = self.code_carbon_callback.tracker._prepare_emissions_data()
            super_dict['co2_eq_emissions'] = {'emissions': float(emissions_data.emissions) * 1000, 'source': 'codecarbon', 'training_type': 'fine-tuning', 'on_cloud': emissions_data.on_cloud == 'Y', 'cpu_model': emissions_data.cpu_model, 'ram_total_size': emissions_data.ram_total_size, 'hours_used': round(emissions_data.duration / 3600, 3)}
            if emissions_data.gpu_model:
                super_dict['co2_eq_emissions']['hardware_used'] = emissions_data.gpu_model
        if self.dataset_id:
            super_dict['datasets'] = [self.dataset_id]
        if self.st_id:
            super_dict['base_model'] = self.st_id
        super_dict['model_max_length'] = self.model.model_body.get_max_seq_length()
        if super_dict['num_classes'] is None:
            if self.model.labels:
                super_dict['num_classes'] = len(self.model.labels)
        if super_dict['absa']:
            super_dict.update(super_dict.pop('absa'))
        for key in IGNORED_FIELDS:
            super_dict.pop(key, None)
        return super_dict

    def to_yaml(self, line_break=None) -> str:
        return yaml_dump({key: value for (key, value) in self.to_dict().items() if key in YAML_FIELDS and value is not None}, sort_keys=False, line_break=line_break).strip()

def is_on_huggingface(repo_id: str, is_model: bool=True) -> bool:
    if len(repo_id.split('/')) > 2:
        return False
    try:
        if is_model:
            model_info(repo_id)
        else:
            dataset_info(repo_id)
        return True
    except Exception:
        return False

def generate_model_card(model: 'SetFitModel') -> str:
    template_path = Path(__file__).parent / 'model_card_template.md'
    model_card = ModelCard.from_template(card_data=model.model_card_data, template_path=template_path, hf_emoji='🤗')
    return model_card.content

# File: setfit-main/src/setfit/modeling.py
import json
import os
import tempfile
import warnings
from pathlib import Path
from typing import Dict, List, Literal, Optional, Set, Tuple, Union
import joblib
import numpy as np
import requests
import torch
from huggingface_hub import ModelHubMixin, hf_hub_download
from huggingface_hub.utils import validate_hf_hub_args
from packaging.version import Version, parse
from sentence_transformers import SentenceTransformer
from sentence_transformers import __version__ as sentence_transformers_version
from sentence_transformers import models
from sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OneVsRestClassifier
from sklearn.multioutput import ClassifierChain, MultiOutputClassifier
from torch import nn
from torch.utils.data import DataLoader
from tqdm.auto import tqdm, trange
from transformers.utils import copy_func
from . import logging
from .data import SetFitDataset
from .model_card import SetFitModelCardData, generate_model_card
from .utils import set_docstring
logging.set_verbosity_info()
logger = logging.get_logger(__name__)
MODEL_HEAD_NAME = 'model_head.pkl'
CONFIG_NAME = 'config_setfit.json'

class SetFitHead(models.Dense):

    def __init__(self, in_features: Optional[int]=None, out_features: int=2, temperature: float=1.0, eps: float=1e-05, bias: bool=True, device: Optional[Union[torch.device, str]]=None, multitarget: bool=False) -> None:
        super(models.Dense, self).__init__()
        if out_features == 1:
            logger.warning('Change `out_features` from 1 to 2 since we use `CrossEntropyLoss` for binary classification.')
            out_features = 2
        if in_features is not None:
            self.linear = nn.Linear(in_features, out_features, bias=bias)
        else:
            self.linear = nn.LazyLinear(out_features, bias=bias)
        self.in_features = in_features
        self.out_features = out_features
        self.temperature = temperature
        self.eps = eps
        self.bias = bias
        self._device = device or 'cuda' if torch.cuda.is_available() else 'cpu'
        self.multitarget = multitarget
        self.to(self._device)
        self.apply(self._init_weight)

    def forward(self, features: Union[Dict[str, torch.Tensor], torch.Tensor], temperature: Optional[float]=None) -> Union[Dict[str, torch.Tensor], Tuple[torch.Tensor]]:
        temperature = temperature or self.temperature
        is_features_dict = False
        if isinstance(features, dict):
            assert 'sentence_embedding' in features
            is_features_dict = True
        x = features['sentence_embedding'] if is_features_dict else features
        logits = self.linear(x)
        logits = logits / (temperature + self.eps)
        if self.multitarget:
            probs = torch.sigmoid(logits)
        else:
            probs = nn.functional.softmax(logits, dim=-1)
        if is_features_dict:
            features.update({'logits': logits, 'probs': probs})
            return features
        return (logits, probs)

    def predict_proba(self, x_test: torch.Tensor) -> torch.Tensor:
        self.eval()
        return self(x_test)[1]

    def predict(self, x_test: torch.Tensor) -> torch.Tensor:
        probs = self.predict_proba(x_test)
        if self.multitarget:
            return torch.where(probs >= 0.5, 1, 0)
        return torch.argmax(probs, dim=-1)

    def get_loss_fn(self) -> nn.Module:
        if self.multitarget:
            return torch.nn.BCEWithLogitsLoss()
        return torch.nn.CrossEntropyLoss()

    @property
    def device(self) -> torch.device:
        return next(self.parameters()).device

    def get_config_dict(self) -> Dict[str, Optional[Union[int, float, bool]]]:
        return {'in_features': self.in_features, 'out_features': self.out_features, 'temperature': self.temperature, 'bias': self.bias, 'device': self.device.type}

    @staticmethod
    def _init_weight(module) -> None:
        if isinstance(module, nn.Linear):
            nn.init.xavier_uniform_(module.weight)
            if module.bias is not None:
                nn.init.constant_(module.bias, 0.01)

    def __repr__(self) -> str:
        return 'SetFitHead({})'.format(self.get_config_dict())

class SetFitModel(ModelHubMixin):

    def __init__(self, model_body: Optional[SentenceTransformer]=None, model_head: Optional[Union[SetFitHead, LogisticRegression]]=None, multi_target_strategy: Optional[str]=None, normalize_embeddings: bool=False, labels: Optional[List[str]]=None, model_card_data: Optional[SetFitModelCardData]=None, sentence_transformers_kwargs: Optional[Dict]=None, **kwargs) -> None:
        super(SetFitModel, self).__init__()
        self.model_body = model_body
        self.model_head = model_head
        self.multi_target_strategy = multi_target_strategy
        self.normalize_embeddings = normalize_embeddings
        self.labels = labels
        self.model_card_data = model_card_data or SetFitModelCardData()
        self.sentence_transformers_kwargs = sentence_transformers_kwargs or {}
        self.attributes_to_save: Set[str] = {'normalize_embeddings', 'labels'}
        self.model_card_data.register_model(self)

    @property
    def has_differentiable_head(self) -> bool:
        return isinstance(self.model_head, nn.Module)

    @property
    def id2label(self) -> Dict[int, str]:
        if self.labels is None:
            return {}
        return dict(enumerate(self.labels))

    @property
    def label2id(self) -> Dict[str, int]:
        if self.labels is None:
            return {}
        return {label: idx for (idx, label) in enumerate(self.labels)}

    def fit(self, x_train: List[str], y_train: Union[List[int], List[List[int]]], num_epochs: int, batch_size: Optional[int]=None, body_learning_rate: Optional[float]=None, head_learning_rate: Optional[float]=None, end_to_end: bool=False, l2_weight: Optional[float]=None, max_length: Optional[int]=None, show_progress_bar: bool=True) -> None:
        if self.has_differentiable_head:
            self.model_body.train()
            self.model_head.train()
            if not end_to_end:
                self.freeze('body')
            dataloader = self._prepare_dataloader(x_train, y_train, batch_size, max_length)
            criterion = self.model_head.get_loss_fn()
            optimizer = self._prepare_optimizer(head_learning_rate, body_learning_rate, l2_weight)
            scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.5)
            for epoch_idx in trange(num_epochs, desc='Epoch', disable=not show_progress_bar):
                for batch in tqdm(dataloader, desc='Iteration', disable=not show_progress_bar, leave=False):
                    (features, labels) = batch
                    optimizer.zero_grad()
                    features = {k: v.to(self.device) for (k, v) in features.items()}
                    labels = labels.to(self.device)
                    outputs = self.model_body(features)
                    if self.normalize_embeddings:
                        outputs['sentence_embedding'] = nn.functional.normalize(outputs['sentence_embedding'], p=2, dim=1)
                    outputs = self.model_head(outputs)
                    logits = outputs['logits']
                    loss: torch.Tensor = criterion(logits, labels)
                    loss.backward()
                    optimizer.step()
                scheduler.step()
            if not end_to_end:
                self.unfreeze('body')
        else:
            embeddings = self.model_body.encode(x_train, normalize_embeddings=self.normalize_embeddings)
            self.model_head.fit(embeddings, y_train)
            if self.labels is None and self.multi_target_strategy is None:
                try:
                    classes = self.model_head.classes_
                    if classes.dtype.char == 'U':
                        self.labels = classes.tolist()
                except Exception:
                    pass

    def _prepare_dataloader(self, x_train: List[str], y_train: Union[List[int], List[List[int]]], batch_size: Optional[int]=None, max_length: Optional[int]=None, shuffle: bool=True) -> DataLoader:
        max_acceptable_length = self.model_body.get_max_seq_length()
        if max_length is None:
            max_length = max_acceptable_length
            logger.warning(f'The `max_length` is `None`. Using the maximum acceptable length according to the current model body: {max_length}.')
        if max_length > max_acceptable_length:
            logger.warning(f'The specified `max_length`: {max_length} is greater than the maximum length of the current model body: {max_acceptable_length}. Using {max_acceptable_length} instead.')
            max_length = max_acceptable_length
        dataset = SetFitDataset(x_train, y_train, tokenizer=self.model_body.tokenizer, max_length=max_length)
        dataloader = DataLoader(dataset, batch_size=batch_size, collate_fn=dataset.collate_fn, shuffle=shuffle, pin_memory=True)
        return dataloader

    def _prepare_optimizer(self, head_learning_rate: float, body_learning_rate: Optional[float], l2_weight: float) -> torch.optim.Optimizer:
        body_learning_rate = body_learning_rate or head_learning_rate
        l2_weight = l2_weight or 0.01
        optimizer = torch.optim.AdamW([{'params': self.model_body.parameters(), 'lr': body_learning_rate, 'weight_decay': l2_weight}, {'params': self.model_head.parameters(), 'lr': head_learning_rate, 'weight_decay': l2_weight}])
        return optimizer

    def freeze(self, component: Optional[Literal['body', 'head']]=None) -> None:
        if component is None or component == 'body':
            self._freeze_or_not(self.model_body, to_freeze=True)
        if (component is None or component == 'head') and self.has_differentiable_head:
            self._freeze_or_not(self.model_head, to_freeze=True)

    def unfreeze(self, component: Optional[Literal['body', 'head']]=None, keep_body_frozen: Optional[bool]=None) -> None:
        if keep_body_frozen is not None:
            warnings.warn('`keep_body_frozen` is deprecated and will be removed in v2.0.0 of SetFit. Please either pass "head", "body" or no arguments to unfreeze both.', DeprecationWarning, stacklevel=2)
            if keep_body_frozen and (not component):
                component = 'head'
        if component is None or component == 'body':
            self._freeze_or_not(self.model_body, to_freeze=False)
        if (component is None or component == 'head') and self.has_differentiable_head:
            self._freeze_or_not(self.model_head, to_freeze=False)

    def _freeze_or_not(self, model: nn.Module, to_freeze: bool) -> None:
        for param in model.parameters():
            param.requires_grad = not to_freeze

    def encode(self, inputs: List[str], batch_size: int=32, show_progress_bar: Optional[bool]=None) -> Union[torch.Tensor, np.ndarray]:
        return self.model_body.encode(inputs, batch_size=batch_size, normalize_embeddings=self.normalize_embeddings, convert_to_tensor=self.has_differentiable_head, show_progress_bar=show_progress_bar)

    def _output_type_conversion(self, outputs: Union[torch.Tensor, np.ndarray], as_numpy: bool=False) -> Union[torch.Tensor, np.ndarray]:
        if as_numpy and self.has_differentiable_head:
            outputs = outputs.detach().cpu().numpy()
        elif not as_numpy and (not self.has_differentiable_head) and (outputs.dtype.char != 'U'):
            outputs = torch.from_numpy(outputs)
        return outputs

    def predict_proba(self, inputs: Union[str, List[str]], batch_size: int=32, as_numpy: bool=False, show_progress_bar: Optional[bool]=None) -> Union[torch.Tensor, np.ndarray]:
        is_singular = isinstance(inputs, str)
        if is_singular:
            inputs = [inputs]
        embeddings = self.encode(inputs, batch_size=batch_size, show_progress_bar=show_progress_bar)
        probs = self.model_head.predict_proba(embeddings)
        if isinstance(probs, list):
            if self.has_differentiable_head:
                probs = torch.stack(probs, axis=1)
            else:
                probs = np.stack(probs, axis=1)
        outputs = self._output_type_conversion(probs, as_numpy=as_numpy)
        return outputs[0] if is_singular else outputs

    def predict(self, inputs: Union[str, List[str]], batch_size: int=32, as_numpy: bool=False, use_labels: bool=True, show_progress_bar: Optional[bool]=None) -> Union[torch.Tensor, np.ndarray, List[str], int, str]:
        is_singular = isinstance(inputs, str)
        if is_singular:
            inputs = [inputs]
        embeddings = self.encode(inputs, batch_size=batch_size, show_progress_bar=show_progress_bar)
        preds = self.model_head.predict(embeddings)
        if use_labels and self.labels and (preds.ndim == 1) and (self.has_differentiable_head or preds.dtype.char != 'U'):
            outputs = [self.labels[int(pred)] for pred in preds]
        else:
            outputs = self._output_type_conversion(preds, as_numpy=as_numpy)
        return outputs[0] if is_singular else outputs

    def __call__(self, inputs: Union[str, List[str]], batch_size: int=32, as_numpy: bool=False, use_labels: bool=True, show_progress_bar: Optional[bool]=None) -> Union[torch.Tensor, np.ndarray, List[str], int, str]:
        return self.predict(inputs, batch_size=batch_size, as_numpy=as_numpy, use_labels=use_labels, show_progress_bar=show_progress_bar)

    @property
    def device(self) -> torch.device:
        if parse(sentence_transformers_version) >= Version('2.3.0'):
            return self.model_body.device
        return self.model_body._target_device

    def to(self, device: Union[str, torch.device]) -> 'SetFitModel':
        if parse(sentence_transformers_version) < Version('2.3.0'):
            self.model_body._target_device = device if isinstance(device, torch.device) else torch.device(device)
        self.model_body = self.model_body.to(device)
        if self.has_differentiable_head:
            self.model_head = self.model_head.to(device)
        return self

    def create_model_card(self, path: str, model_name: Optional[str]='SetFit Model') -> None:
        if not os.path.exists(path):
            os.makedirs(path)
        model_path = Path(model_name)
        if self.model_card_data.model_id is None and model_path.exists() and (Path(tempfile.gettempdir()) in model_path.resolve().parents):
            self.model_card_data.model_id = '/'.join(model_path.parts[-2:])
        with open(os.path.join(path, 'README.md'), 'w', encoding='utf-8') as f:
            f.write(self.generate_model_card())

    def generate_model_card(self) -> str:
        return generate_model_card(self)

    def _save_pretrained(self, save_directory: Union[Path, str]) -> None:
        save_directory = str(save_directory)
        config_path = os.path.join(save_directory, CONFIG_NAME)
        with open(config_path, 'w') as f:
            json.dump({attr_name: getattr(self, attr_name) for attr_name in self.attributes_to_save if hasattr(self, attr_name)}, f, indent=2)
        self.model_body.save(path=save_directory, create_model_card=False)
        self.create_model_card(path=save_directory, model_name=save_directory)
        if self.has_differentiable_head:
            self.model_head.to('cpu')
        joblib.dump(self.model_head, str(Path(save_directory) / MODEL_HEAD_NAME))
        if self.has_differentiable_head:
            self.model_head.to(self.device)

    @classmethod
    @validate_hf_hub_args
    def _from_pretrained(cls, model_id: str, revision: Optional[str]=None, cache_dir: Optional[str]=None, force_download: Optional[bool]=None, proxies: Optional[Dict]=None, resume_download: Optional[bool]=None, local_files_only: Optional[bool]=None, token: Optional[Union[bool, str]]=None, multi_target_strategy: Optional[str]=None, use_differentiable_head: bool=False, device: Optional[Union[torch.device, str]]=None, trust_remote_code: bool=False, **model_kwargs) -> 'SetFitModel':
        sentence_transformers_kwargs = {'cache_folder': cache_dir, 'use_auth_token': token, 'device': device, 'trust_remote_code': trust_remote_code}
        if parse(sentence_transformers_version) >= Version('2.3.0'):
            sentence_transformers_kwargs = {'cache_folder': cache_dir, 'token': token, 'device': device, 'trust_remote_code': trust_remote_code}
        else:
            if trust_remote_code:
                raise ValueError('The `trust_remote_code` argument is only supported for `sentence-transformers` >= 2.3.0.')
            sentence_transformers_kwargs = {'cache_folder': cache_dir, 'use_auth_token': token, 'device': device}
        model_body = SentenceTransformer(model_id, **sentence_transformers_kwargs)
        if parse(sentence_transformers_version) >= Version('2.3.0'):
            device = model_body.device
        else:
            device = model_body._target_device
        model_body.to(device)
        config_file: Optional[str] = None
        if os.path.isdir(model_id):
            if CONFIG_NAME in os.listdir(model_id):
                config_file = os.path.join(model_id, CONFIG_NAME)
        else:
            try:
                config_file = hf_hub_download(repo_id=model_id, filename=CONFIG_NAME, revision=revision, cache_dir=cache_dir, force_download=force_download, proxies=proxies, resume_download=resume_download, token=token, local_files_only=local_files_only)
            except requests.exceptions.RequestException:
                pass
        model_kwargs = {key: value for (key, value) in model_kwargs.items() if value is not None}
        if config_file is not None:
            with open(config_file, 'r', encoding='utf-8') as f:
                config = json.load(f)
            for (setting, value) in config.items():
                if setting in model_kwargs:
                    if model_kwargs[setting] != value:
                        logger.warning(f'Overriding {setting} in model configuration from {value} to {model_kwargs[setting]}.')
                else:
                    model_kwargs[setting] = value
        if os.path.isdir(model_id):
            if MODEL_HEAD_NAME in os.listdir(model_id):
                model_head_file = os.path.join(model_id, MODEL_HEAD_NAME)
            else:
                logger.info(f'{MODEL_HEAD_NAME} not found in {Path(model_id).resolve()}, initialising classification head with random weights. You should TRAIN this model on a downstream task to use it for predictions and inference.')
                model_head_file = None
        else:
            try:
                model_head_file = hf_hub_download(repo_id=model_id, filename=MODEL_HEAD_NAME, revision=revision, cache_dir=cache_dir, force_download=force_download, proxies=proxies, resume_download=resume_download, token=token, local_files_only=local_files_only)
            except requests.exceptions.RequestException:
                logger.info(f'{MODEL_HEAD_NAME} not found on HuggingFace Hub, initialising classification head with random weights. You should TRAIN this model on a downstream task to use it for predictions and inference.')
                model_head_file = None
        model_card_data: SetFitModelCardData = model_kwargs.pop('model_card_data', SetFitModelCardData())
        if model_head_file is not None:
            model_head = joblib.load(model_head_file)
            if isinstance(model_head, torch.nn.Module):
                model_head.to(device)
            model_card_data.infer_st_id(model_id)
        else:
            head_params = model_kwargs.pop('head_params', {})
            if use_differentiable_head:
                if multi_target_strategy is None:
                    use_multitarget = False
                elif multi_target_strategy in ['one-vs-rest', 'multi-output']:
                    use_multitarget = True
                else:
                    raise ValueError(f"multi_target_strategy '{multi_target_strategy}' is not supported for differentiable head")
                base_head_params = {'in_features': model_body.get_sentence_embedding_dimension(), 'device': device, 'multitarget': use_multitarget}
                model_head = SetFitHead(**{**head_params, **base_head_params})
            else:
                clf = LogisticRegression(**head_params)
                if multi_target_strategy is not None:
                    if multi_target_strategy == 'one-vs-rest':
                        multilabel_classifier = OneVsRestClassifier(clf)
                    elif multi_target_strategy == 'multi-output':
                        multilabel_classifier = MultiOutputClassifier(clf)
                    elif multi_target_strategy == 'classifier-chain':
                        multilabel_classifier = ClassifierChain(clf)
                    else:
                        raise ValueError(f'multi_target_strategy {multi_target_strategy} is not supported.')
                    model_head = multilabel_classifier
                else:
                    model_head = clf
            model_card_data.set_st_id(model_id if '/' in model_id else f'sentence-transformers/{model_id}')
        model_kwargs.pop('config', None)
        return cls(model_body=model_body, model_head=model_head, multi_target_strategy=multi_target_strategy, model_card_data=model_card_data, sentence_transformers_kwargs=sentence_transformers_kwargs, **model_kwargs)
docstring = SetFitModel.from_pretrained.__doc__
cut_index = docstring.find('model_kwargs')
if cut_index != -1:
    docstring = docstring[:cut_index] + 'labels (`List[str]`, *optional*):\n                If the labels are integers ranging from `0` to `num_classes-1`, then these labels indicate\n                    the corresponding labels.\n            model_card_data (`SetFitModelCardData`, *optional*):\n                A `SetFitModelCardData` instance storing data such as model language, license, dataset name,\n                    etc. to be used in the automatically generated model cards.\n            multi_target_strategy (`str`, *optional*):\n                The strategy to use with multi-label classification. One of "one-vs-rest", "multi-output",\n                    or "classifier-chain".\n            use_differentiable_head (`bool`, *optional*):\n                Whether to load SetFit using a differentiable (i.e., Torch) head instead of Logistic Regression.\n            normalize_embeddings (`bool`, *optional*):\n                Whether to apply normalization on the embeddings produced by the Sentence Transformer body.\n            device (`Union[torch.device, str]`, *optional*):\n                The device on which to load the SetFit model, e.g. `"cuda:0"`, `"mps"` or `torch.device("cuda")`.\n            trust_remote_code (`bool`, defaults to `False`): Whether or not to allow for custom Sentence Transformers\n                models defined on the Hub in their own modeling files. This option should only be set to True for\n                repositories you trust and in which you have read the code, as it will execute code present on\n                the Hub on your local machine. Defaults to False.\n\n        Example::\n\n            >>> from setfit import SetFitModel\n            >>> model = SetFitModel.from_pretrained(\n            ...     "sentence-transformers/paraphrase-mpnet-base-v2",\n            ...     labels=["positive", "negative"],\n            ... )\n        '
    SetFitModel.from_pretrained = set_docstring(SetFitModel.from_pretrained, docstring)
SetFitModel.save_pretrained = copy_func(SetFitModel.save_pretrained)
SetFitModel.save_pretrained.__doc__ = SetFitModel.save_pretrained.__doc__.replace('~ModelHubMixin._from_pretrained', 'SetFitModel.push_to_hub')

# File: setfit-main/src/setfit/sampler.py
from itertools import zip_longest
from typing import Generator, Iterable, List, Optional
import numpy as np
import torch
from sentence_transformers import InputExample
from torch.utils.data import IterableDataset
from . import logging
logging.set_verbosity_info()
logger = logging.get_logger(__name__)

def shuffle_combinations(iterable: Iterable, replacement: bool=True) -> Generator:
    n = len(iterable)
    k = 1 if not replacement else 0
    idxs = np.stack(np.triu_indices(n, k), axis=-1)
    for i in np.random.RandomState(seed=42).permutation(len(idxs)):
        (_idx, idx) = idxs[i, :]
        yield (iterable[_idx], iterable[idx])

class ContrastiveDataset(IterableDataset):

    def __init__(self, examples: List[InputExample], multilabel: bool, num_iterations: Optional[None]=None, sampling_strategy: str='oversampling', max_pairs: int=-1) -> None:
        super().__init__()
        self.pos_index = 0
        self.neg_index = 0
        self.pos_pairs = []
        self.neg_pairs = []
        self.sentences = np.array([s.texts[0] for s in examples])
        self.labels = np.array([s.label for s in examples])
        self.sentence_labels = list(zip(self.sentences, self.labels))
        self.max_pairs = max_pairs
        if multilabel:
            self.generate_multilabel_pairs()
        else:
            self.generate_pairs()
        if num_iterations is not None and num_iterations > 0:
            self.len_pos_pairs = num_iterations * len(self.sentences)
            self.len_neg_pairs = num_iterations * len(self.sentences)
        elif sampling_strategy == 'unique':
            self.len_pos_pairs = len(self.pos_pairs)
            self.len_neg_pairs = len(self.neg_pairs)
        elif sampling_strategy == 'undersampling':
            self.len_pos_pairs = min(len(self.pos_pairs), len(self.neg_pairs))
            self.len_neg_pairs = min(len(self.pos_pairs), len(self.neg_pairs))
        elif sampling_strategy == 'oversampling':
            self.len_pos_pairs = max(len(self.pos_pairs), len(self.neg_pairs))
            self.len_neg_pairs = max(len(self.pos_pairs), len(self.neg_pairs))
        else:
            raise ValueError("Invalid sampling strategy. Must be one of 'unique', 'oversampling', or 'undersampling'.")

    def generate_pairs(self) -> None:
        for ((_text, _label), (text, label)) in shuffle_combinations(self.sentence_labels):
            if _label == label:
                self.pos_pairs.append(InputExample(texts=[_text, text], label=1.0))
            else:
                self.neg_pairs.append(InputExample(texts=[_text, text], label=0.0))
            if self.max_pairs != -1 and len(self.pos_pairs) > self.max_pairs and (len(self.neg_pairs) > self.max_pairs):
                break

    def generate_multilabel_pairs(self) -> None:
        for ((_text, _label), (text, label)) in shuffle_combinations(self.sentence_labels):
            if any(np.logical_and(_label, label)):
                self.pos_pairs.append(InputExample(texts=[_text, text], label=1.0))
            else:
                self.neg_pairs.append(InputExample(texts=[_text, text], label=0.0))
            if self.max_pairs != -1 and len(self.pos_pairs) > self.max_pairs and (len(self.neg_pairs) > self.max_pairs):
                break

    def get_positive_pairs(self) -> List[InputExample]:
        pairs = []
        for _ in range(self.len_pos_pairs):
            if self.pos_index >= len(self.pos_pairs):
                self.pos_index = 0
            pairs.append(self.pos_pairs[self.pos_index])
            self.pos_index += 1
        return pairs

    def get_negative_pairs(self) -> List[InputExample]:
        pairs = []
        for _ in range(self.len_neg_pairs):
            if self.neg_index >= len(self.neg_pairs):
                self.neg_index = 0
            pairs.append(self.neg_pairs[self.neg_index])
            self.neg_index += 1
        return pairs

    def __iter__(self):
        for (pos_pair, neg_pair) in zip_longest(self.get_positive_pairs(), self.get_negative_pairs()):
            if pos_pair is not None:
                yield pos_pair
            if neg_pair is not None:
                yield neg_pair

    def __len__(self) -> int:
        return self.len_pos_pairs + self.len_neg_pairs

class ContrastiveDistillationDataset(ContrastiveDataset):

    def __init__(self, examples: List[InputExample], cos_sim_matrix: torch.Tensor, num_iterations: Optional[None]=None, sampling_strategy: str='oversampling', max_pairs: int=-1) -> None:
        self.cos_sim_matrix = cos_sim_matrix
        super().__init__(examples, multilabel=False, num_iterations=num_iterations, sampling_strategy=sampling_strategy, max_pairs=max_pairs)
        self.sentence_labels = list(enumerate(self.sentences))
        self.len_neg_pairs = 0
        if num_iterations is not None and num_iterations > 0:
            self.len_pos_pairs = num_iterations * len(self.sentences)
        else:
            self.len_pos_pairs = len(self.pos_pairs)

    def generate_pairs(self) -> None:
        for ((text_one, id_one), (text_two, id_two)) in shuffle_combinations(self.sentence_labels):
            self.pos_pairs.append(InputExample(texts=[text_one, text_two], label=self.cos_sim_matrix[id_one][id_two]))
            if self.max_pairs != -1 and len(self.pos_pairs) > self.max_pairs:
                break

# File: setfit-main/src/setfit/span/aspect_extractor.py
from typing import TYPE_CHECKING, List, Tuple
if TYPE_CHECKING:
    from spacy.tokens import Doc

class AspectExtractor:

    def __init__(self, spacy_model: str) -> None:
        super().__init__()
        import spacy
        self.nlp = spacy.load(spacy_model)

    def find_groups(self, aspect_mask: List[bool]):
        start = None
        for (idx, flag) in enumerate(aspect_mask):
            if flag:
                if start is None:
                    start = idx
            elif start is not None:
                yield slice(start, idx)
                start = None
        if start is not None:
            yield slice(start, idx + 1)

    def __call__(self, texts: List[str]) -> Tuple[List['Doc'], List[slice]]:
        aspects_list = []
        docs = list(self.nlp.pipe(texts))
        for doc in docs:
            aspect_mask = [token.pos_ in ('NOUN', 'PROPN') for token in doc]
            aspects_list.append(list(self.find_groups(aspect_mask)))
        return (docs, aspects_list)

# File: setfit-main/src/setfit/span/modeling.py
import copy
import os
import re
import tempfile
import types
from collections import defaultdict
from dataclasses import dataclass
from pathlib import Path
from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Tuple, Union
import torch
from datasets import Dataset
from huggingface_hub.utils import SoftTemporaryDirectory
from setfit.utils import set_docstring
from .. import logging
from ..modeling import SetFitModel
from .aspect_extractor import AspectExtractor
if TYPE_CHECKING:
    from spacy.tokens import Doc
logger = logging.get_logger(__name__)

class SpanSetFitModel(SetFitModel):

    def __init__(self, spacy_model: str='en_core_web_lg', span_context: int=0, **kwargs):
        super().__init__(**kwargs)
        self.spacy_model = spacy_model
        self.span_context = span_context
        self.attributes_to_save = {'normalize_embeddings', 'labels', 'span_context', 'spacy_model'}

    def prepend_aspects(self, docs: List['Doc'], aspects_list: List[List[slice]]) -> Iterable[str]:
        for (doc, aspects) in zip(docs, aspects_list):
            for aspect_slice in aspects:
                aspect = doc[max(aspect_slice.start - self.span_context, 0):aspect_slice.stop + self.span_context]
                yield (aspect.text + ':' + doc.text)

    def __call__(self, docs: List['Doc'], aspects_list: List[List[slice]]) -> List[bool]:
        inputs_list = list(self.prepend_aspects(docs, aspects_list))
        preds = self.predict(inputs_list, as_numpy=True)
        iter_preds = iter(preds)
        return [[next(iter_preds) for _ in aspects] for aspects in aspects_list]

    def create_model_card(self, path: str, model_name: Optional[str]=None) -> None:
        if not os.path.exists(path):
            os.makedirs(path)
        model_path = Path(model_name)
        if model_path.exists() and Path(tempfile.gettempdir()) in model_path.resolve().parents:
            model_name = '/'.join(model_path.parts[-2:])
        is_aspect = isinstance(self, AspectModel)
        aspect_model = 'setfit-absa-aspect'
        polarity_model = 'setfit-absa-polarity'
        if model_name is not None:
            if is_aspect:
                aspect_model = model_name
                if model_name.endswith('-aspect'):
                    polarity_model = model_name[:-len('-aspect')] + '-polarity'
            else:
                polarity_model = model_name
                if model_name.endswith('-polarity'):
                    aspect_model = model_name[:-len('-polarity')] + '-aspect'
        if self.model_card_data.absa is None and self.model_card_data.model_name:
            from spacy import __version__ as spacy_version
            self.model_card_data.model_name = self.model_card_data.model_name.replace('SetFit', 'SetFit Aspect Model' if is_aspect else 'SetFit Polarity Model', 1)
            self.model_card_data.tags.insert(1, 'absa')
            self.model_card_data.version['spacy'] = spacy_version
        self.model_card_data.absa = {'is_absa': True, 'is_aspect': is_aspect, 'spacy_model': self.spacy_model, 'aspect_model': aspect_model, 'polarity_model': polarity_model}
        if self.model_card_data.task_name is None:
            self.model_card_data.task_name = 'Aspect Based Sentiment Analysis (ABSA)'
        self.model_card_data.inference = False
        with open(os.path.join(path, 'README.md'), 'w', encoding='utf-8') as f:
            f.write(self.generate_model_card())
docstring = SpanSetFitModel.from_pretrained.__doc__
cut_index = docstring.find('multi_target_strategy')
if cut_index != -1:
    docstring = docstring[:cut_index] + 'model_card_data (`SetFitModelCardData`, *optional*):\n                A `SetFitModelCardData` instance storing data such as model language, license, dataset name,\n                    etc. to be used in the automatically generated model cards.\n            use_differentiable_head (`bool`, *optional*):\n                Whether to load SetFit using a differentiable (i.e., Torch) head instead of Logistic Regression.\n            normalize_embeddings (`bool`, *optional*):\n                Whether to apply normalization on the embeddings produced by the Sentence Transformer body.\n            span_context (`int`, defaults to `0`):\n                The number of words before and after the span candidate that should be prepended to the full sentence.\n                By default, 0 for Aspect models and 3 for Polarity models.\n            device (`Union[torch.device, str]`, *optional*):\n                The device on which to load the SetFit model, e.g. `"cuda:0"`, `"mps"` or `torch.device("cuda")`.'
    SpanSetFitModel.from_pretrained = set_docstring(SpanSetFitModel.from_pretrained, docstring, cls=SpanSetFitModel)

class AspectModel(SpanSetFitModel):

    def __call__(self, docs: List['Doc'], aspects_list: List[List[slice]]) -> List[bool]:
        sentence_preds = super().__call__(docs, aspects_list)
        return [[aspect for (aspect, pred) in zip(aspects, preds) if pred == 'aspect'] for (aspects, preds) in zip(aspects_list, sentence_preds)]
AspectModel.from_pretrained = types.MethodType(AspectModel.from_pretrained.__func__, AspectModel)

class PolarityModel(SpanSetFitModel):

    def __init__(self, span_context: int=3, **kwargs):
        super().__init__(**kwargs)
        self.span_context = span_context
PolarityModel.from_pretrained = types.MethodType(PolarityModel.from_pretrained.__func__, PolarityModel)

@dataclass
class AbsaModel:
    aspect_extractor: AspectExtractor
    aspect_model: AspectModel
    polarity_model: PolarityModel

    def gold_aspect_spans_to_aspects_list(self, inputs: Dataset) -> List[List[slice]]:
        grouped_data = defaultdict(list)
        for sample in inputs:
            text = sample.pop('text')
            grouped_data[text].append(sample)
        (docs, _) = self.aspect_extractor(grouped_data.keys())
        aspects_list = []
        index = -1
        skipped_indices = []
        for (doc, samples) in zip(docs, grouped_data.values()):
            aspects_list.append([])
            for sample in samples:
                index += 1
                match_objects = re.finditer(re.escape(sample['span']), doc.text)
                for (i, match) in enumerate(match_objects):
                    if i == sample['ordinal']:
                        char_idx_start = match.start()
                        char_idx_end = match.end()
                        span = doc.char_span(char_idx_start, char_idx_end)
                        if span is None:
                            logger.warning(f"Aspect term {sample['span']!r} with ordinal {sample['ordinal']}, isn't a token in {doc.text!r} according to spaCy. Skipping this sample.")
                            skipped_indices.append(index)
                            continue
                        aspects_list[-1].append(slice(span.start, span.end))
        return (docs, aspects_list, skipped_indices)

    def predict_dataset(self, inputs: Dataset) -> Dataset:
        if set(inputs.column_names) >= {'text', 'span', 'ordinal'}:
            pass
        elif set(inputs.column_names) >= {'text', 'span'}:
            inputs = inputs.add_column('ordinal', [0] * len(inputs))
        else:
            raise ValueError(f'`inputs` must be either a `str`, a `List[str]`, or a `datasets.Dataset` with columns `text` and `span` and optionally `ordinal`. Found a dataset with these columns: {inputs.column_names}.')
        if 'pred_polarity' in inputs.column_names:
            raise ValueError('`predict_dataset` wants to add a `pred_polarity` column, but the input dataset already contains that column.')
        (docs, aspects_list, skipped_indices) = self.gold_aspect_spans_to_aspects_list(inputs)
        polarity_list = sum(self.polarity_model(docs, aspects_list), [])
        for index in skipped_indices:
            polarity_list.insert(index, None)
        return inputs.add_column('pred_polarity', polarity_list)

    def predict(self, inputs: Union[str, List[str], Dataset]) -> Union[List[Dict[str, Any]], Dataset]:
        if isinstance(inputs, Dataset):
            return self.predict_dataset(inputs)
        is_str = isinstance(inputs, str)
        inputs_list = [inputs] if is_str else inputs
        (docs, aspects_list) = self.aspect_extractor(inputs_list)
        if sum(aspects_list, []) == []:
            return aspects_list
        aspects_list = self.aspect_model(docs, aspects_list)
        if sum(aspects_list, []) == []:
            return aspects_list
        polarity_list = self.polarity_model(docs, aspects_list)
        outputs = []
        for (docs, aspects, polarities) in zip(docs, aspects_list, polarity_list):
            outputs.append([{'span': docs[aspect_slice].text, 'polarity': polarity} for (aspect_slice, polarity) in zip(aspects, polarities)])
        return outputs if not is_str else outputs[0]

    @property
    def device(self) -> torch.device:
        return self.aspect_model.device

    def to(self, device: Union[str, torch.device]) -> 'AbsaModel':
        self.aspect_model.to(device)
        self.polarity_model.to(device)

    def __call__(self, inputs: Union[str, List[str]]) -> List[Dict[str, Any]]:
        return self.predict(inputs)

    def save_pretrained(self, save_directory: Union[str, Path], polarity_save_directory: Optional[Union[str, Path]]=None, push_to_hub: bool=False, **kwargs) -> None:
        if polarity_save_directory is None:
            base_save_directory = Path(save_directory)
            save_directory = base_save_directory.parent / (base_save_directory.name + '-aspect')
            polarity_save_directory = base_save_directory.parent / (base_save_directory.name + '-polarity')
        self.aspect_model.save_pretrained(save_directory=save_directory, push_to_hub=push_to_hub, **kwargs)
        self.polarity_model.save_pretrained(save_directory=polarity_save_directory, push_to_hub=push_to_hub, **kwargs)

    @classmethod
    def from_pretrained(cls, model_id: str, polarity_model_id: Optional[str]=None, spacy_model: Optional[str]=None, span_contexts: Tuple[Optional[int], Optional[int]]=(None, None), force_download: bool=None, resume_download: bool=None, proxies: Optional[Dict]=None, token: Optional[Union[str, bool]]=None, cache_dir: Optional[str]=None, local_files_only: bool=None, use_differentiable_head: bool=None, normalize_embeddings: bool=None, **model_kwargs) -> 'AbsaModel':
        revision = None
        if len(model_id.split('@')) == 2:
            (model_id, revision) = model_id.split('@')
        if spacy_model:
            model_kwargs['spacy_model'] = spacy_model
        aspect_model = AspectModel.from_pretrained(model_id, span_context=span_contexts[0], revision=revision, force_download=force_download, resume_download=resume_download, proxies=proxies, token=token, cache_dir=cache_dir, local_files_only=local_files_only, use_differentiable_head=use_differentiable_head, normalize_embeddings=normalize_embeddings, labels=['no aspect', 'aspect'], **model_kwargs)
        if polarity_model_id:
            model_id = polarity_model_id
            revision = None
            if len(model_id.split('@')) == 2:
                (model_id, revision) = model_id.split('@')
        model_card_data = model_kwargs.pop('model_card_data', None)
        if model_card_data:
            model_kwargs['model_card_data'] = copy.deepcopy(model_card_data)
        polarity_model = PolarityModel.from_pretrained(model_id, span_context=span_contexts[1], revision=revision, force_download=force_download, resume_download=resume_download, proxies=proxies, token=token, cache_dir=cache_dir, local_files_only=local_files_only, use_differentiable_head=use_differentiable_head, normalize_embeddings=normalize_embeddings, **model_kwargs)
        if aspect_model.spacy_model != polarity_model.spacy_model:
            logger.warning(f'The Aspect and Polarity models are configured to use different spaCy models:\n* {repr(aspect_model.spacy_model)} for the aspect model, and\n* {repr(polarity_model.spacy_model)} for the polarity model.\nThis model will use {repr(aspect_model.spacy_model)}.')
        aspect_extractor = AspectExtractor(spacy_model=aspect_model.spacy_model)
        return cls(aspect_extractor, aspect_model, polarity_model)

    def push_to_hub(self, repo_id: str, polarity_repo_id: Optional[str]=None, **kwargs) -> None:
        if '/' not in repo_id:
            raise ValueError('`repo_id` must be a full repository ID, including organisation, e.g. "tomaarsen/setfit-absa-restaurant".')
        if polarity_repo_id is not None and '/' not in polarity_repo_id:
            raise ValueError('`polarity_repo_id` must be a full repository ID, including organisation, e.g. "tomaarsen/setfit-absa-restaurant".')
        commit_message = kwargs.pop('commit_message', 'Add SetFit ABSA model')
        with SoftTemporaryDirectory() as tmp_dir:
            save_directory = Path(tmp_dir) / repo_id
            polarity_save_directory = None if polarity_repo_id is None else Path(tmp_dir) / polarity_repo_id
            self.save_pretrained(save_directory=save_directory, polarity_save_directory=polarity_save_directory, push_to_hub=True, commit_message=commit_message, **kwargs)

# File: setfit-main/src/setfit/span/trainer.py
from collections import defaultdict
from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
from datasets import Dataset
from transformers.trainer_callback import TrainerCallback
from setfit.span.modeling import AbsaModel, AspectModel, PolarityModel
from setfit.training_args import TrainingArguments
from .. import logging
from ..trainer import ColumnMappingMixin, Trainer
if TYPE_CHECKING:
    import optuna
logger = logging.get_logger(__name__)

class AbsaTrainer(ColumnMappingMixin):
    _REQUIRED_COLUMNS = {'text', 'span', 'label', 'ordinal'}

    def __init__(self, model: AbsaModel, args: Optional[TrainingArguments]=None, polarity_args: Optional[TrainingArguments]=None, train_dataset: Optional['Dataset']=None, eval_dataset: Optional['Dataset']=None, metric: Union[str, Callable[['Dataset', 'Dataset'], Dict[str, float]]]='accuracy', metric_kwargs: Optional[Dict[str, Any]]=None, callbacks: Optional[List[TrainerCallback]]=None, column_mapping: Optional[Dict[str, str]]=None) -> None:
        self.model = model
        self.aspect_extractor = model.aspect_extractor
        if train_dataset is not None and column_mapping:
            train_dataset = self._apply_column_mapping(train_dataset, column_mapping)
        (aspect_train_dataset, polarity_train_dataset) = self.preprocess_dataset(model.aspect_model, model.polarity_model, train_dataset)
        if eval_dataset is not None and column_mapping:
            eval_dataset = self._apply_column_mapping(eval_dataset, column_mapping)
        (aspect_eval_dataset, polarity_eval_dataset) = self.preprocess_dataset(model.aspect_model, model.polarity_model, eval_dataset)
        self.aspect_trainer = Trainer(model.aspect_model, args=args, train_dataset=aspect_train_dataset, eval_dataset=aspect_eval_dataset, metric=metric, metric_kwargs=metric_kwargs, callbacks=callbacks)
        self.aspect_trainer._set_logs_mapper({'eval_embedding_loss': 'eval_aspect_embedding_loss', 'embedding_loss': 'aspect_embedding_loss'})
        self.polarity_trainer = Trainer(model.polarity_model, args=polarity_args or args, train_dataset=polarity_train_dataset, eval_dataset=polarity_eval_dataset, metric=metric, metric_kwargs=metric_kwargs, callbacks=callbacks)
        self.polarity_trainer._set_logs_mapper({'eval_embedding_loss': 'eval_polarity_embedding_loss', 'embedding_loss': 'polarity_embedding_loss'})

    def preprocess_dataset(self, aspect_model: AspectModel, polarity_model: PolarityModel, dataset: Dataset) -> Dataset:
        if dataset is None:
            return (dataset, dataset)
        grouped_data = defaultdict(list)
        for sample in dataset:
            text = sample.pop('text')
            grouped_data[text].append(sample)

        def index_ordinal(text: str, target: str, ordinal: int) -> Tuple[int, int]:
            find_from = 0
            for _ in range(ordinal + 1):
                start_idx = text.index(target, find_from)
                find_from = start_idx + 1
            return (start_idx, start_idx + len(target))

        def overlaps(aspect: slice, aspects: List[slice]) -> bool:
            for test_aspect in aspects:
                overlapping_indices = set(range(aspect.start, aspect.stop + 1)) & set(range(test_aspect.start, test_aspect.stop + 1))
                if overlapping_indices:
                    return True
            return False
        (docs, aspects_list) = self.aspect_extractor(grouped_data.keys())
        aspect_aspect_list = []
        aspect_labels = []
        polarity_aspect_list = []
        polarity_labels = []
        for (doc, aspects, text) in zip(docs, aspects_list, grouped_data):
            gold_aspects = []
            gold_polarity_labels = []
            for annotation in grouped_data[text]:
                try:
                    (start, end) = index_ordinal(text, annotation['span'], annotation['ordinal'])
                except ValueError:
                    logger.info(f"The ordinal of {annotation['ordinal']} for span {annotation['span']!r} in {text!r} is too high. Skipping this sample.")
                    continue
                gold_aspect_span = doc.char_span(start, end)
                if gold_aspect_span is None:
                    continue
                gold_aspects.append(slice(gold_aspect_span.start, gold_aspect_span.end))
                gold_polarity_labels.append(annotation['label'])
            aspect_labels.extend([True] * len(gold_aspects))
            aspect_aspect_list.append(gold_aspects[:])
            for aspect in aspects:
                if not overlaps(aspect, gold_aspects):
                    aspect_labels.append(False)
                    aspect_aspect_list[-1].append(aspect)
            polarity_labels.extend(gold_polarity_labels)
            polarity_aspect_list.append(gold_aspects)
        aspect_texts = list(aspect_model.prepend_aspects(docs, aspect_aspect_list))
        polarity_texts = list(polarity_model.prepend_aspects(docs, polarity_aspect_list))
        return (Dataset.from_dict({'text': aspect_texts, 'label': aspect_labels}), Dataset.from_dict({'text': polarity_texts, 'label': polarity_labels}))

    def train(self, args: Optional[TrainingArguments]=None, polarity_args: Optional[TrainingArguments]=None, trial: Optional[Union['optuna.Trial', Dict[str, Any]]]=None, **kwargs) -> None:
        self.train_aspect(args=args, trial=trial, **kwargs)
        self.train_polarity(args=polarity_args, trial=trial, **kwargs)

    def train_aspect(self, args: Optional[TrainingArguments]=None, trial: Optional[Union['optuna.Trial', Dict[str, Any]]]=None, **kwargs) -> None:
        self.aspect_trainer.train(args=args, trial=trial, **kwargs)

    def train_polarity(self, args: Optional[TrainingArguments]=None, trial: Optional[Union['optuna.Trial', Dict[str, Any]]]=None, **kwargs) -> None:
        self.polarity_trainer.train(args=args, trial=trial, **kwargs)

    def add_callback(self, callback: Union[type, TrainerCallback]) -> None:
        self.aspect_trainer.add_callback(callback)
        self.polarity_trainer.add_callback(callback)

    def pop_callback(self, callback: Union[type, TrainerCallback]) -> Tuple[TrainerCallback, TrainerCallback]:
        return (self.aspect_trainer.pop_callback(callback), self.polarity_trainer.pop_callback(callback))

    def remove_callback(self, callback: Union[type, TrainerCallback]) -> None:
        self.aspect_trainer.remove_callback(callback)
        self.polarity_trainer.remove_callback(callback)

    def push_to_hub(self, repo_id: str, polarity_repo_id: Optional[str]=None, **kwargs) -> None:
        return self.model.push_to_hub(repo_id=repo_id, polarity_repo_id=polarity_repo_id, **kwargs)

    def evaluate(self, dataset: Optional[Dataset]=None) -> Dict[str, Dict[str, float]]:
        aspect_eval_dataset = polarity_eval_dataset = None
        if dataset:
            (aspect_eval_dataset, polarity_eval_dataset) = self.preprocess_dataset(self.model.aspect_model, self.model.polarity_model, dataset)
        return {'aspect': self.aspect_trainer.evaluate(aspect_eval_dataset), 'polarity': self.polarity_trainer.evaluate(polarity_eval_dataset)}

# File: setfit-main/src/setfit/trainer.py
import math
import os
import shutil
import time
import warnings
from pathlib import Path
from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Literal, Optional, Tuple, Union
import evaluate
import torch
from datasets import Dataset, DatasetDict
from sentence_transformers import InputExample, SentenceTransformer, losses
from sentence_transformers.datasets import SentenceLabelDataset
from sentence_transformers.losses.BatchHardTripletLoss import BatchHardTripletLossDistanceFunction
from sentence_transformers.util import batch_to_device
from sklearn.preprocessing import LabelEncoder
from torch import nn
from torch.cuda.amp import autocast
from torch.utils.data import DataLoader
from tqdm.autonotebook import tqdm
from transformers.integrations import WandbCallback, get_reporting_integration_callbacks
from transformers.trainer_callback import CallbackHandler, DefaultFlowCallback, IntervalStrategy, PrinterCallback, ProgressCallback, TrainerCallback, TrainerControl, TrainerState
from transformers.trainer_utils import HPSearchBackend, default_compute_objective, number_of_arguments, set_seed, speed_metrics
from transformers.utils.import_utils import is_in_notebook
from setfit.model_card import ModelCardCallback
from . import logging
from .integrations import default_hp_search_backend, is_optuna_available, run_hp_search_optuna
from .losses import SupConLoss
from .sampler import ContrastiveDataset
from .training_args import TrainingArguments
from .utils import BestRun, default_hp_space_optuna
if TYPE_CHECKING:
    import optuna
    from .modeling import SetFitModel
logging.set_verbosity_info()
logger = logging.get_logger(__name__)
DEFAULT_CALLBACKS = [DefaultFlowCallback]
DEFAULT_PROGRESS_CALLBACK = ProgressCallback
if is_in_notebook():
    from transformers.utils.notebook import NotebookProgressCallback
    DEFAULT_PROGRESS_CALLBACK = NotebookProgressCallback

class ColumnMappingMixin:
    _REQUIRED_COLUMNS = {'text', 'label'}

    def _validate_column_mapping(self, dataset: 'Dataset') -> None:
        column_names = set(dataset.column_names)
        if self.column_mapping is None and (not self._REQUIRED_COLUMNS.issubset(column_names)):
            if column_names == {'train'} and isinstance(dataset, DatasetDict):
                raise ValueError("SetFit expected a Dataset, but it got a DatasetDict with the split ['train']. Did you mean to select the training split with dataset['train']?")
            elif isinstance(dataset, DatasetDict):
                raise ValueError(f'SetFit expected a Dataset, but it got a DatasetDict with the splits {sorted(column_names)}. Did you mean to select one of these splits from the dataset?')
            else:
                raise ValueError(f'SetFit expected the dataset to have the columns {sorted(self._REQUIRED_COLUMNS)}, but only the columns {sorted(column_names)} were found. Either make sure these columns are present, or specify which columns to use with column_mapping in Trainer.')
        if self.column_mapping is not None:
            missing_columns = set(self._REQUIRED_COLUMNS)
            missing_columns -= set(self.column_mapping.values())
            missing_columns -= set(dataset.column_names) - set(self.column_mapping.keys())
            if missing_columns:
                raise ValueError(f'The following columns are missing from the column mapping: {missing_columns}. Please provide a mapping for all required columns.')
            if not set(self.column_mapping.keys()).issubset(column_names):
                raise ValueError(f'The column mapping expected the columns {sorted(self.column_mapping.keys())} in the dataset, but the dataset had the columns {sorted(column_names)}.')

    def _apply_column_mapping(self, dataset: 'Dataset', column_mapping: Dict[str, str]) -> 'Dataset':
        dataset = dataset.rename_columns({**column_mapping, **{col: f'feat_{col}' for col in dataset.column_names if col not in column_mapping and col not in self._REQUIRED_COLUMNS}})
        dset_format = dataset.format
        dataset = dataset.with_format(type=dset_format['type'], columns=dataset.column_names, output_all_columns=dset_format['output_all_columns'], **dset_format['format_kwargs'])
        return dataset

class Trainer(ColumnMappingMixin):

    def __init__(self, model: Optional['SetFitModel']=None, args: Optional[TrainingArguments]=None, train_dataset: Optional['Dataset']=None, eval_dataset: Optional['Dataset']=None, model_init: Optional[Callable[[], 'SetFitModel']]=None, metric: Union[str, Callable[['Dataset', 'Dataset'], Dict[str, float]]]='accuracy', metric_kwargs: Optional[Dict[str, Any]]=None, callbacks: Optional[List[TrainerCallback]]=None, column_mapping: Optional[Dict[str, str]]=None) -> None:
        if args is not None and (not isinstance(args, TrainingArguments)):
            raise ValueError('`args` must be a `TrainingArguments` instance imported from `setfit`.')
        self.args = args or TrainingArguments()
        self.column_mapping = column_mapping
        if train_dataset:
            self._validate_column_mapping(train_dataset)
            if self.column_mapping is not None:
                logger.info('Applying column mapping to the training dataset')
                train_dataset = self._apply_column_mapping(train_dataset, self.column_mapping)
        self.train_dataset = train_dataset
        if eval_dataset:
            self._validate_column_mapping(eval_dataset)
            if self.column_mapping is not None:
                logger.info('Applying column mapping to the evaluation dataset')
                eval_dataset = self._apply_column_mapping(eval_dataset, self.column_mapping)
        self.eval_dataset = eval_dataset
        self.model_init = model_init
        self.metric = metric
        self.metric_kwargs = metric_kwargs
        self.logs_mapper = {}
        set_seed(12)
        if model is None:
            if model_init is not None:
                model = self.call_model_init()
            else:
                raise RuntimeError('`Trainer` requires either a `model` or `model_init` argument.')
        elif model_init is not None:
            raise RuntimeError('`Trainer` requires either a `model` or `model_init` argument, but not both.')
        self.model = model
        self.hp_search_backend = None
        default_callbacks = DEFAULT_CALLBACKS + get_reporting_integration_callbacks(self.args.report_to)
        callbacks = default_callbacks if callbacks is None else default_callbacks + callbacks
        if WandbCallback in callbacks:
            os.environ.setdefault('WANDB_PROJECT', 'setfit')
        self.callback_handler = CallbackHandler(callbacks, self.model, self.model.model_body.tokenizer, None, None)
        self.state = TrainerState()
        self.control = TrainerControl()
        self.add_callback(DEFAULT_PROGRESS_CALLBACK if self.args.show_progress_bar else PrinterCallback)
        self.control = self.callback_handler.on_init_end(self.args, self.state, self.control)
        self.add_callback(ModelCardCallback(self))
        self.callback_handler.on_init_end(args, self.state, self.control)

    def add_callback(self, callback: Union[type, TrainerCallback]) -> None:
        self.callback_handler.add_callback(callback)

    def pop_callback(self, callback: Union[type, TrainerCallback]) -> TrainerCallback:
        return self.callback_handler.pop_callback(callback)

    def remove_callback(self, callback: Union[type, TrainerCallback]) -> None:
        self.callback_handler.remove_callback(callback)

    def apply_hyperparameters(self, params: Dict[str, Any], final_model: bool=False) -> None:
        if self.args is not None:
            self.args = self.args.update(params, ignore_extra=True)
        else:
            self.args = TrainingArguments.from_dict(params, ignore_extra=True)
        set_seed(self.args.seed)
        self.model = self.model_init(params)
        if final_model:
            self.model_init = None

    def _hp_search_setup(self, trial: Union['optuna.Trial', Dict[str, Any]]) -> None:
        if self.hp_search_backend is None or trial is None:
            return
        if isinstance(trial, Dict):
            params = trial
        elif self.hp_search_backend == HPSearchBackend.OPTUNA:
            params = self.hp_space(trial)
        else:
            raise ValueError('Invalid trial parameter')
        logger.info(f'Trial: {params}')
        self.apply_hyperparameters(params, final_model=False)

    def call_model_init(self, params: Optional[Dict[str, Any]]=None) -> 'SetFitModel':
        model_init_argcount = number_of_arguments(self.model_init)
        if model_init_argcount == 0:
            model = self.model_init()
        elif model_init_argcount == 1:
            model = self.model_init(params)
        else:
            raise RuntimeError('`model_init` should have 0 or 1 argument.')
        if model is None:
            raise RuntimeError('`model_init` should not return None.')
        return model

    def freeze(self, component: Optional[Literal['body', 'head']]=None) -> None:
        warnings.warn(f'`{self.__class__.__name__}.freeze` is deprecated and will be removed in v2.0.0 of SetFit. Please use `SetFitModel.freeze` directly instead.', DeprecationWarning, stacklevel=2)
        return self.model.freeze(component)

    def unfreeze(self, component: Optional[Literal['body', 'head']]=None, keep_body_frozen: Optional[bool]=None) -> None:
        warnings.warn(f'`{self.__class__.__name__}.unfreeze` is deprecated and will be removed in v2.0.0 of SetFit. Please use `SetFitModel.unfreeze` directly instead.', DeprecationWarning, stacklevel=2)
        return self.model.unfreeze(component, keep_body_frozen=keep_body_frozen)

    def train(self, args: Optional[TrainingArguments]=None, trial: Optional[Union['optuna.Trial', Dict[str, Any]]]=None, **kwargs) -> None:
        if len(kwargs):
            warnings.warn(f'`{self.__class__.__name__}.train` does not accept keyword arguments anymore. Please provide training arguments via a `TrainingArguments` instance to the `{self.__class__.__name__}` initialisation or the `{self.__class__.__name__}.train` method.', DeprecationWarning, stacklevel=2)
        if trial:
            self._hp_search_setup(trial)
        args = args or self.args or TrainingArguments()
        if self.train_dataset is None:
            raise ValueError(f'Training requires a `train_dataset` given to the `{self.__class__.__name__}` initialization.')
        train_parameters = self.dataset_to_parameters(self.train_dataset)
        full_parameters = train_parameters + self.dataset_to_parameters(self.eval_dataset) if self.eval_dataset else train_parameters
        self.train_embeddings(*full_parameters, args=args)
        self.train_classifier(*train_parameters, args=args)

    def dataset_to_parameters(self, dataset: Dataset) -> List[Iterable]:
        return [dataset['text'], dataset['label']]

    def train_embeddings(self, x_train: List[str], y_train: Optional[Union[List[int], List[List[int]]]]=None, x_eval: Optional[List[str]]=None, y_eval: Optional[Union[List[int], List[List[int]]]]=None, args: Optional[TrainingArguments]=None) -> None:
        args = args or self.args or TrainingArguments()
        self.state.logging_steps = args.logging_steps
        self.state.eval_steps = args.eval_steps
        self.state.save_steps = args.save_steps
        self.state.global_step = 0
        self.state.total_flos = 0
        train_max_pairs = -1 if args.max_steps == -1 else args.max_steps * args.embedding_batch_size
        (train_dataloader, loss_func, batch_size, num_unique_pairs) = self.get_dataloader(x_train, y_train, args=args, max_pairs=train_max_pairs)
        if x_eval is not None and args.eval_strategy != IntervalStrategy.NO:
            eval_max_pairs = -1 if args.eval_max_steps == -1 else args.eval_max_steps * args.embedding_batch_size
            (eval_dataloader, _, _, _) = self.get_dataloader(x_eval, y_eval, args=args, max_pairs=eval_max_pairs)
        else:
            eval_dataloader = None
        total_train_steps = len(train_dataloader) * args.embedding_num_epochs
        if args.max_steps > 0:
            total_train_steps = min(args.max_steps, total_train_steps)
        logger.info('***** Running training *****')
        logger.info(f'  Num unique pairs = {num_unique_pairs}')
        logger.info(f'  Batch size = {batch_size}')
        logger.info(f'  Num epochs = {args.embedding_num_epochs}')
        logger.info(f'  Total optimization steps = {total_train_steps}')
        warmup_steps = math.ceil(total_train_steps * args.warmup_proportion)
        self._train_sentence_transformer(self.model.model_body, train_dataloader=train_dataloader, eval_dataloader=eval_dataloader, args=args, loss_func=loss_func, warmup_steps=warmup_steps)

    def get_dataloader(self, x: List[str], y: Union[List[int], List[List[int]]], args: TrainingArguments, max_pairs: int=-1) -> Tuple[DataLoader, nn.Module, int, int]:
        input_data = [InputExample(texts=[text], label=label) for (text, label) in zip(x, y)]
        if args.loss in [losses.BatchAllTripletLoss, losses.BatchHardTripletLoss, losses.BatchSemiHardTripletLoss, losses.BatchHardSoftMarginTripletLoss, SupConLoss]:
            data_sampler = SentenceLabelDataset(input_data, samples_per_label=args.samples_per_label)
            batch_size = min(args.embedding_batch_size, len(data_sampler))
            dataloader = DataLoader(data_sampler, batch_size=batch_size, drop_last=True)
            if args.loss is losses.BatchHardSoftMarginTripletLoss:
                loss = args.loss(model=self.model.model_body, distance_metric=args.distance_metric)
            elif args.loss is SupConLoss:
                loss = args.loss(model=self.model.model_body)
            else:
                loss = args.loss(model=self.model.model_body, distance_metric=args.distance_metric, margin=args.margin)
        else:
            data_sampler = ContrastiveDataset(input_data, self.model.multi_target_strategy, args.num_iterations, args.sampling_strategy, max_pairs=max_pairs)
            batch_size = min(args.embedding_batch_size, len(data_sampler))
            dataloader = DataLoader(data_sampler, batch_size=batch_size, drop_last=False)
            loss = args.loss(self.model.model_body)
        return (dataloader, loss, batch_size, len(data_sampler))

    def log(self, args: TrainingArguments, logs: Dict[str, float]) -> None:
        logs = {self.logs_mapper.get(key, key): value for (key, value) in logs.items()}
        if self.state.epoch is not None:
            logs['epoch'] = round(self.state.epoch, 2)
        output = {**logs, **{'step': self.state.global_step}}
        self.state.log_history.append(output)
        return self.callback_handler.on_log(args, self.state, self.control, logs)

    def _set_logs_mapper(self, logs_mapper: Dict[str, str]) -> None:
        self.logs_mapper = logs_mapper

    def _train_sentence_transformer(self, model_body: SentenceTransformer, train_dataloader: DataLoader, eval_dataloader: Optional[DataLoader], args: TrainingArguments, loss_func: nn.Module, warmup_steps: int=10000) -> None:
        max_grad_norm = 1
        weight_decay = 0.01
        self.state.epoch = 0
        start_time = time.time()
        if args.max_steps > 0:
            self.state.max_steps = args.max_steps
        else:
            self.state.max_steps = len(train_dataloader) * args.embedding_num_epochs
        self.control = self.callback_handler.on_train_begin(args, self.state, self.control)
        steps_per_epoch = len(train_dataloader)
        if args.use_amp:
            scaler = torch.cuda.amp.GradScaler()
        model_body.to(self.model.device)
        loss_func.to(self.model.device)
        train_dataloader.collate_fn = model_body.smart_batching_collate
        if eval_dataloader:
            eval_dataloader.collate_fn = model_body.smart_batching_collate
        param_optimizer = list(loss_func.named_parameters())
        no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
        optimizer_grouped_parameters = [{'params': [p for (n, p) in param_optimizer if not any((nd in n for nd in no_decay))], 'weight_decay': weight_decay}, {'params': [p for (n, p) in param_optimizer if any((nd in n for nd in no_decay))], 'weight_decay': 0.0}]
        optimizer = torch.optim.AdamW(optimizer_grouped_parameters, **{'lr': args.body_embedding_learning_rate})
        scheduler_obj = model_body._get_scheduler(optimizer, scheduler='WarmupLinear', warmup_steps=warmup_steps, t_total=self.state.max_steps)
        self.callback_handler.optimizer = optimizer
        self.callback_handler.lr_scheduler = scheduler_obj
        self.callback_handler.train_dataloader = train_dataloader
        self.callback_handler.eval_dataloader = eval_dataloader
        self.callback_handler.on_train_begin(args, self.state, self.control)
        data_iterator = iter(train_dataloader)
        skip_scheduler = False
        for epoch in range(args.embedding_num_epochs):
            self.control = self.callback_handler.on_epoch_begin(args, self.state, self.control)
            loss_func.zero_grad()
            loss_func.train()
            for step in range(steps_per_epoch):
                self.control = self.callback_handler.on_step_begin(args, self.state, self.control)
                try:
                    data = next(data_iterator)
                except StopIteration:
                    data_iterator = iter(train_dataloader)
                    data = next(data_iterator)
                (features, labels) = data
                labels = labels.to(self.model.device)
                features = list(map(lambda batch: batch_to_device(batch, self.model.device), features))
                if args.use_amp:
                    with autocast():
                        loss_value = loss_func(features, labels)
                    scale_before_step = scaler.get_scale()
                    scaler.scale(loss_value).backward()
                    scaler.unscale_(optimizer)
                    torch.nn.utils.clip_grad_norm_(loss_func.parameters(), max_grad_norm)
                    scaler.step(optimizer)
                    scaler.update()
                    skip_scheduler = scaler.get_scale() != scale_before_step
                else:
                    loss_value = loss_func(features, labels)
                    loss_value.backward()
                    torch.nn.utils.clip_grad_norm_(loss_func.parameters(), max_grad_norm)
                    optimizer.step()
                optimizer.zero_grad()
                if not skip_scheduler:
                    scheduler_obj.step()
                self.state.global_step += 1
                self.state.epoch = epoch + (step + 1) / steps_per_epoch
                self.control = self.callback_handler.on_step_end(args, self.state, self.control)
                self.maybe_log_eval_save(model_body, eval_dataloader, args, scheduler_obj, loss_func, loss_value)
                if self.control.should_epoch_stop or self.control.should_training_stop:
                    break
            self.control = self.callback_handler.on_epoch_end(args, self.state, self.control)
            self.maybe_log_eval_save(model_body, eval_dataloader, args, scheduler_obj, loss_func, loss_value)
            if self.control.should_training_stop:
                break
        if self.args.load_best_model_at_end and self.state.best_model_checkpoint:
            dir_name = Path(self.state.best_model_checkpoint).name
            if dir_name.startswith('step_'):
                step_to_load = dir_name[5:]
                logger.info(f'Loading best SentenceTransformer model from step {step_to_load}.')
                self.model.model_card_data.set_best_model_step(int(step_to_load))
            sentence_transformer_kwargs = self.model.sentence_transformers_kwargs
            sentence_transformer_kwargs['device'] = self.model.device
            self.model.model_body = SentenceTransformer(self.state.best_model_checkpoint, **sentence_transformer_kwargs)
            self.model.model_body.to(self.model.device)
        num_train_samples = self.state.max_steps * args.embedding_batch_size
        metrics = speed_metrics('train', start_time, num_samples=num_train_samples, num_steps=self.state.max_steps)
        self.control.should_log = True
        self.log(args, metrics)
        self.control = self.callback_handler.on_train_end(args, self.state, self.control)

    def maybe_log_eval_save(self, model_body: SentenceTransformer, eval_dataloader: Optional[DataLoader], args: TrainingArguments, scheduler_obj, loss_func, loss_value: torch.Tensor) -> None:
        if self.control.should_log:
            learning_rate = scheduler_obj.get_last_lr()[0]
            metrics = {'embedding_loss': round(loss_value.item(), 4), 'learning_rate': learning_rate}
            self.control = self.log(args, metrics)
        eval_loss = None
        if self.control.should_evaluate and eval_dataloader is not None:
            eval_loss = self._evaluate_with_loss(model_body, eval_dataloader, args, loss_func)
            learning_rate = scheduler_obj.get_last_lr()[0]
            metrics = {'eval_embedding_loss': round(eval_loss, 4), 'learning_rate': learning_rate}
            self.control = self.log(args, metrics)
            self.control = self.callback_handler.on_evaluate(args, self.state, self.control, metrics)
            loss_func.zero_grad()
            loss_func.train()
        if self.control.should_save:
            checkpoint_dir = self._checkpoint(self.args.output_dir, args.save_total_limit, self.state.global_step)
            self.control = self.callback_handler.on_save(self.args, self.state, self.control)
            if eval_loss is not None and (self.state.best_metric is None or eval_loss < self.state.best_metric):
                self.state.best_metric = eval_loss
                self.state.best_model_checkpoint = checkpoint_dir

    def _evaluate_with_loss(self, model_body: SentenceTransformer, eval_dataloader: DataLoader, args: TrainingArguments, loss_func: nn.Module) -> float:
        model_body.eval()
        losses = []
        eval_steps = min(len(eval_dataloader), args.eval_max_steps) if args.eval_max_steps != -1 else len(eval_dataloader)
        for (step, data) in enumerate(tqdm(iter(eval_dataloader), total=eval_steps, leave=False, disable=not args.show_progress_bar), start=1):
            (features, labels) = data
            labels = labels.to(self.model.device)
            features = list(map(lambda batch: batch_to_device(batch, self.model.device), features))
            if args.use_amp:
                with autocast():
                    loss_value = loss_func(features, labels)
                losses.append(loss_value.item())
            else:
                losses.append(loss_func(features, labels).item())
            if step >= eval_steps:
                break
        model_body.train()
        return sum(losses) / len(losses)

    def _checkpoint(self, checkpoint_path: str, checkpoint_save_total_limit: int, step: int) -> None:
        if checkpoint_save_total_limit is not None and checkpoint_save_total_limit > 0:
            old_checkpoints = []
            for subdir in Path(checkpoint_path).glob('step_*'):
                if subdir.name[5:].isdigit() and (self.state.best_model_checkpoint is None or subdir != Path(self.state.best_model_checkpoint)):
                    old_checkpoints.append({'step': int(subdir.name[5:]), 'path': str(subdir)})
            if len(old_checkpoints) > checkpoint_save_total_limit - 1:
                old_checkpoints = sorted(old_checkpoints, key=lambda x: x['step'])
                shutil.rmtree(old_checkpoints[0]['path'])
        checkpoint_file_path = str(Path(checkpoint_path) / f'step_{step}')
        self.model.save_pretrained(checkpoint_file_path)
        return checkpoint_file_path

    def train_classifier(self, x_train: List[str], y_train: Union[List[int], List[List[int]]], args: Optional[TrainingArguments]=None) -> None:
        args = args or self.args or TrainingArguments()
        self.model.fit(x_train, y_train, num_epochs=args.classifier_num_epochs, batch_size=args.classifier_batch_size, body_learning_rate=args.body_classifier_learning_rate, head_learning_rate=args.head_learning_rate, l2_weight=args.l2_weight, max_length=args.max_length, show_progress_bar=args.show_progress_bar, end_to_end=args.end_to_end)

    def evaluate(self, dataset: Optional[Dataset]=None, metric_key_prefix: str='test') -> Dict[str, float]:
        if dataset is not None:
            self._validate_column_mapping(dataset)
            if self.column_mapping is not None:
                logger.info('Applying column mapping to the evaluation dataset')
                eval_dataset = self._apply_column_mapping(dataset, self.column_mapping)
            else:
                eval_dataset = dataset
        else:
            eval_dataset = self.eval_dataset
        if eval_dataset is None:
            raise ValueError('No evaluation dataset provided to `Trainer.evaluate` nor the `Trainer` initialzation.')
        x_test = eval_dataset['text']
        y_test = eval_dataset['label']
        logger.info('***** Running evaluation *****')
        y_pred = self.model.predict(x_test, use_labels=False)
        if isinstance(y_pred, torch.Tensor):
            y_pred = y_pred.cpu()
        if y_test and isinstance(y_test[0], str):
            encoder = LabelEncoder()
            encoder.fit(list(y_test) + list(y_pred))
            y_test = encoder.transform(y_test)
            y_pred = encoder.transform(y_pred)
        metric_kwargs = self.metric_kwargs or {}
        if isinstance(self.metric, str):
            metric_config = 'multilabel' if self.model.multi_target_strategy is not None else None
            metric_fn = evaluate.load(self.metric, config_name=metric_config)
            results = metric_fn.compute(predictions=y_pred, references=y_test, **metric_kwargs)
        elif callable(self.metric):
            results = self.metric(y_pred, y_test, **metric_kwargs)
        else:
            raise ValueError('metric must be a string or a callable')
        if not isinstance(results, dict):
            results = {'metric': results}
        self.model.model_card_data.post_training_eval_results({f'{metric_key_prefix}_{key}': value for (key, value) in results.items()})
        return results

    def hyperparameter_search(self, hp_space: Optional[Callable[['optuna.Trial'], Dict[str, float]]]=None, compute_objective: Optional[Callable[[Dict[str, float]], float]]=None, n_trials: int=10, direction: str='maximize', backend: Optional[Union['str', HPSearchBackend]]=None, hp_name: Optional[Callable[['optuna.Trial'], str]]=None, **kwargs) -> BestRun:
        if backend is None:
            backend = default_hp_search_backend()
            if backend is None:
                raise RuntimeError('optuna should be installed. To install optuna run `pip install optuna`.')
        backend = HPSearchBackend(backend)
        if backend == HPSearchBackend.OPTUNA and (not is_optuna_available()):
            raise RuntimeError('You picked the optuna backend, but it is not installed. Use `pip install optuna`.')
        elif backend != HPSearchBackend.OPTUNA:
            raise RuntimeError('Only optuna backend is supported for hyperparameter search.')
        self.hp_search_backend = backend
        if self.model_init is None:
            raise RuntimeError('To use hyperparameter search, you need to pass your model through a model_init function.')
        self.hp_space = default_hp_space_optuna if hp_space is None else hp_space
        self.hp_name = hp_name
        self.compute_objective = default_compute_objective if compute_objective is None else compute_objective
        backend_dict = {HPSearchBackend.OPTUNA: run_hp_search_optuna}
        best_run = backend_dict[backend](self, n_trials, direction, **kwargs)
        self.hp_search_backend = None
        return best_run

    def push_to_hub(self, repo_id: str, **kwargs) -> str:
        if '/' not in repo_id:
            raise ValueError('`repo_id` must be a full repository ID, including organisation, e.g. "tomaarsen/setfit-sst2".')
        commit_message = kwargs.pop('commit_message', 'Add SetFit model')
        return self.model.push_to_hub(repo_id, commit_message=commit_message, **kwargs)

class SetFitTrainer(Trainer):

    def __init__(self, model: Optional['SetFitModel']=None, train_dataset: Optional['Dataset']=None, eval_dataset: Optional['Dataset']=None, model_init: Optional[Callable[[], 'SetFitModel']]=None, metric: Union[str, Callable[['Dataset', 'Dataset'], Dict[str, float]]]='accuracy', metric_kwargs: Optional[Dict[str, Any]]=None, loss_class=losses.CosineSimilarityLoss, num_iterations: int=20, num_epochs: int=1, learning_rate: float=2e-05, batch_size: int=16, seed: int=42, column_mapping: Optional[Dict[str, str]]=None, use_amp: bool=False, warmup_proportion: float=0.1, distance_metric: Callable=BatchHardTripletLossDistanceFunction.cosine_distance, margin: float=0.25, samples_per_label: int=2):
        warnings.warn('`SetFitTrainer` has been deprecated and will be removed in v2.0.0 of SetFit. Please use `Trainer` instead.', DeprecationWarning, stacklevel=2)
        args = TrainingArguments(num_iterations=num_iterations, num_epochs=num_epochs, body_learning_rate=learning_rate, head_learning_rate=learning_rate, batch_size=batch_size, seed=seed, use_amp=use_amp, warmup_proportion=warmup_proportion, distance_metric=distance_metric, margin=margin, samples_per_label=samples_per_label, loss=loss_class)
        super().__init__(model=model, args=args, train_dataset=train_dataset, eval_dataset=eval_dataset, model_init=model_init, metric=metric, metric_kwargs=metric_kwargs, column_mapping=column_mapping)

# File: setfit-main/src/setfit/trainer_distillation.py
import warnings
from typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Optional, Tuple, Union
import torch
from datasets import Dataset
from sentence_transformers import InputExample, losses, util
from torch import nn
from torch.utils.data import DataLoader
from . import logging
from .sampler import ContrastiveDistillationDataset
from .trainer import Trainer
from .training_args import TrainingArguments
if TYPE_CHECKING:
    from .modeling import SetFitModel
logging.set_verbosity_info()
logger = logging.get_logger(__name__)

class DistillationTrainer(Trainer):
    _REQUIRED_COLUMNS = {'text'}

    def __init__(self, teacher_model: 'SetFitModel', student_model: Optional['SetFitModel']=None, args: TrainingArguments=None, train_dataset: Optional['Dataset']=None, eval_dataset: Optional['Dataset']=None, model_init: Optional[Callable[[], 'SetFitModel']]=None, metric: Union[str, Callable[['Dataset', 'Dataset'], Dict[str, float]]]='accuracy', column_mapping: Optional[Dict[str, str]]=None) -> None:
        super().__init__(model=student_model, args=args, train_dataset=train_dataset, eval_dataset=eval_dataset, model_init=model_init, metric=metric, column_mapping=column_mapping)
        self.teacher_model = teacher_model
        self.student_model = self.model

    def dataset_to_parameters(self, dataset: Dataset) -> List[Iterable]:
        return [dataset['text']]

    def get_dataloader(self, x: List[str], y: Optional[Union[List[int], List[List[int]]]], args: TrainingArguments, max_pairs: int=-1) -> Tuple[DataLoader, nn.Module, int, int]:
        x_embd_student = self.teacher_model.model_body.encode(x, convert_to_tensor=self.teacher_model.has_differentiable_head)
        cos_sim_matrix = util.cos_sim(x_embd_student, x_embd_student)
        input_data = [InputExample(texts=[text]) for text in x]
        data_sampler = ContrastiveDistillationDataset(input_data, cos_sim_matrix, args.num_iterations, args.sampling_strategy, max_pairs=max_pairs)
        batch_size = min(args.embedding_batch_size, len(data_sampler))
        dataloader = DataLoader(data_sampler, batch_size=batch_size, drop_last=False)
        loss = args.loss(self.model.model_body)
        return (dataloader, loss, batch_size, len(data_sampler))

    def train_classifier(self, x_train: List[str], args: Optional[TrainingArguments]=None) -> None:
        y_train = self.teacher_model.predict(x_train, as_numpy=not self.student_model.has_differentiable_head)
        return super().train_classifier(x_train, y_train, args)

class DistillationSetFitTrainer(DistillationTrainer):

    def __init__(self, teacher_model: 'SetFitModel', student_model: Optional['SetFitModel']=None, train_dataset: Optional['Dataset']=None, eval_dataset: Optional['Dataset']=None, model_init: Optional[Callable[[], 'SetFitModel']]=None, metric: Union[str, Callable[['Dataset', 'Dataset'], Dict[str, float]]]='accuracy', loss_class: torch.nn.Module=losses.CosineSimilarityLoss, num_iterations: int=20, num_epochs: int=1, learning_rate: float=2e-05, batch_size: int=16, seed: int=42, column_mapping: Optional[Dict[str, str]]=None, use_amp: bool=False, warmup_proportion: float=0.1) -> None:
        warnings.warn('`DistillationSetFitTrainer` has been deprecated and will be removed in v2.0.0 of SetFit. Please use `DistillationTrainer` instead.', DeprecationWarning, stacklevel=2)
        args = TrainingArguments(num_iterations=num_iterations, num_epochs=num_epochs, body_learning_rate=learning_rate, head_learning_rate=learning_rate, batch_size=batch_size, seed=seed, use_amp=use_amp, warmup_proportion=warmup_proportion, loss=loss_class)
        super().__init__(teacher_model=teacher_model, student_model=student_model, args=args, train_dataset=train_dataset, eval_dataset=eval_dataset, model_init=model_init, metric=metric, column_mapping=column_mapping)

# File: setfit-main/src/setfit/training_args.py
from __future__ import annotations
import inspect
import json
from copy import copy
from dataclasses import dataclass, field, fields
from typing import Any, Callable, Dict, Optional, Tuple, Union
import torch
from sentence_transformers import losses
from transformers import IntervalStrategy
from transformers.integrations import get_available_reporting_integrations
from transformers.training_args import default_logdir
from transformers.utils import is_torch_available
from . import logging
logger = logging.get_logger(__name__)

@dataclass
class TrainingArguments:
    output_dir: str = 'checkpoints'
    batch_size: Union[int, Tuple[int, int]] = field(default=(16, 2), repr=False)
    num_epochs: Union[int, Tuple[int, int]] = field(default=(1, 16), repr=False)
    max_steps: int = -1
    sampling_strategy: str = 'oversampling'
    num_iterations: Optional[int] = None
    body_learning_rate: Union[float, Tuple[float, float]] = field(default=(2e-05, 1e-05), repr=False)
    head_learning_rate: float = 0.01
    loss: Callable = losses.CosineSimilarityLoss
    distance_metric: Callable = losses.BatchHardTripletLossDistanceFunction.cosine_distance
    margin: float = 0.25
    end_to_end: bool = field(default=False)
    use_amp: bool = False
    warmup_proportion: float = 0.1
    l2_weight: Optional[float] = None
    max_length: Optional[int] = None
    samples_per_label: int = 2
    show_progress_bar: bool = True
    seed: int = 42
    report_to: str = 'all'
    run_name: Optional[str] = None
    logging_dir: Optional[str] = None
    logging_strategy: str = 'steps'
    logging_first_step: bool = True
    logging_steps: int = 50
    eval_strategy: str = 'no'
    evaluation_strategy: Optional[str] = field(default=None, repr=False)
    eval_steps: Optional[int] = None
    eval_delay: int = 0
    eval_max_steps: int = -1
    save_strategy: str = 'steps'
    save_steps: int = 500
    save_total_limit: Optional[int] = 1
    load_best_model_at_end: bool = False
    metric_for_best_model: str = field(default='embedding_loss', repr=False)
    greater_is_better: bool = field(default=False, repr=False)

    def __post_init__(self) -> None:
        if isinstance(self.batch_size, int):
            self.batch_size = (self.batch_size, self.batch_size)
        if isinstance(self.num_epochs, int):
            self.num_epochs = (self.num_epochs, self.num_epochs)
        if isinstance(self.body_learning_rate, float):
            self.body_learning_rate = (self.body_learning_rate, self.body_learning_rate)
        if self.warmup_proportion < 0.0 or self.warmup_proportion > 1.0:
            raise ValueError(f'warmup_proportion must be greater than or equal to 0.0 and less than or equal to 1.0! But it was: {self.warmup_proportion}')
        if self.report_to in (None, 'all', ['all']):
            self.report_to = get_available_reporting_integrations()
        elif self.report_to in ('none', ['none']):
            self.report_to = []
        elif not isinstance(self.report_to, list):
            self.report_to = [self.report_to]
        if self.logging_dir is None:
            self.logging_dir = default_logdir()
        self.logging_strategy = IntervalStrategy(self.logging_strategy)
        if self.evaluation_strategy is not None:
            logger.warning('The `evaluation_strategy` argument is deprecated and will be removed in a future version. Please use `eval_strategy` instead.')
            self.eval_strategy = self.evaluation_strategy
        self.eval_strategy = IntervalStrategy(self.eval_strategy)
        if self.eval_steps is not None and self.eval_strategy == IntervalStrategy.NO:
            logger.info('Using `eval_strategy="steps"` as `eval_steps` is defined.')
            self.eval_strategy = IntervalStrategy.STEPS
        if self.eval_strategy == IntervalStrategy.STEPS and (self.eval_steps is None or self.eval_steps == 0):
            if self.logging_steps > 0:
                self.eval_steps = self.logging_steps
            else:
                raise ValueError(f'evaluation strategy {self.eval_strategy} requires either non-zero `eval_steps` or `logging_steps`')
        if self.load_best_model_at_end:
            if self.eval_strategy != self.save_strategy:
                raise ValueError(f'`load_best_model_at_end` requires the save and eval strategy to match, but found\n- Evaluation strategy: {self.eval_strategy}\n- Save strategy: {self.save_strategy}')
            if self.eval_strategy == IntervalStrategy.STEPS and self.save_steps % self.eval_steps != 0:
                raise ValueError(f'`load_best_model_at_end` requires the saving steps to be a round multiple of the evaluation steps, but found {self.save_steps}, which is not a round multiple of {self.eval_steps}.')
        if self.logging_strategy == IntervalStrategy.STEPS and self.logging_steps == 0:
            raise ValueError(f'Logging strategy {self.logging_strategy} requires non-zero `logging_steps`')

    @property
    def embedding_batch_size(self) -> int:
        return self.batch_size[0]

    @property
    def classifier_batch_size(self) -> int:
        return self.batch_size[1]

    @property
    def embedding_num_epochs(self) -> int:
        return self.num_epochs[0]

    @property
    def classifier_num_epochs(self) -> int:
        return self.num_epochs[1]

    @property
    def body_embedding_learning_rate(self) -> float:
        return self.body_learning_rate[0]

    @property
    def body_classifier_learning_rate(self) -> float:
        return self.body_learning_rate[1]

    def to_dict(self) -> Dict[str, Any]:
        return {field.name: getattr(self, field.name) for field in fields(self) if field.init}

    @classmethod
    def from_dict(cls, arguments: Dict[str, Any], ignore_extra: bool=False) -> TrainingArguments:
        if ignore_extra:
            return cls(**{key: value for (key, value) in arguments.items() if key in inspect.signature(cls).parameters})
        return cls(**arguments)

    def copy(self) -> TrainingArguments:
        return copy(self)

    def update(self, arguments: Dict[str, Any], ignore_extra: bool=False) -> TrainingArguments:
        return TrainingArguments.from_dict({**self.to_dict(), **arguments}, ignore_extra=ignore_extra)

    def to_json_string(self):
        return json.dumps({key: str(value) for (key, value) in self.to_dict().items()}, indent=2)

    def to_sanitized_dict(self) -> Dict[str, Any]:
        d = self.to_dict()
        d = {**d, **{'train_batch_size': self.embedding_batch_size, 'eval_batch_size': self.embedding_batch_size}}
        valid_types = [bool, int, float, str]
        if is_torch_available():
            valid_types.append(torch.Tensor)
        return {k: v if type(v) in valid_types else str(v) for (k, v) in d.items()}

# File: setfit-main/src/setfit/utils.py
import types
from contextlib import contextmanager
from dataclasses import dataclass, field
from time import monotonic_ns
from typing import Any, Dict, List, NamedTuple, Optional, Tuple
from datasets import Dataset, DatasetDict, load_dataset
from sentence_transformers import losses
from transformers.utils import copy_func
from .data import create_fewshot_splits, create_fewshot_splits_multilabel
from .losses import SupConLoss
SEC_TO_NS_SCALE = 1000000000
DEV_DATASET_TO_METRIC = {'sst2': 'accuracy', 'imdb': 'accuracy', 'subj': 'accuracy', 'bbc-news': 'accuracy', 'enron_spam': 'accuracy', 'student-question-categories': 'accuracy', 'TREC-QC': 'accuracy', 'toxic_conversations': 'matthews_correlation'}
TEST_DATASET_TO_METRIC = {'emotion': 'accuracy', 'SentEval-CR': 'accuracy', 'sst5': 'accuracy', 'ag_news': 'accuracy', 'enron_spam': 'accuracy', 'amazon_counterfactual_en': 'matthews_correlation'}
MULTILINGUAL_DATASET_TO_METRIC = {f'amazon_reviews_multi_{lang}': 'mae' for lang in ['en', 'de', 'es', 'fr', 'ja', 'zh']}
LOSS_NAME_TO_CLASS = {'CosineSimilarityLoss': losses.CosineSimilarityLoss, 'ContrastiveLoss': losses.ContrastiveLoss, 'OnlineContrastiveLoss': losses.OnlineContrastiveLoss, 'BatchSemiHardTripletLoss': losses.BatchSemiHardTripletLoss, 'BatchAllTripletLoss': losses.BatchAllTripletLoss, 'BatchHardTripletLoss': losses.BatchHardTripletLoss, 'BatchHardSoftMarginTripletLoss': losses.BatchHardSoftMarginTripletLoss, 'SupConLoss': SupConLoss}

def default_hp_space_optuna(trial) -> Dict[str, Any]:
    from transformers.integrations import is_optuna_available
    assert is_optuna_available(), 'This function needs Optuna installed: `pip install optuna`'
    return {'learning_rate': trial.suggest_float('learning_rate', 1e-06, 0.0001, log=True), 'num_epochs': trial.suggest_int('num_epochs', 1, 5), 'num_iterations': trial.suggest_categorical('num_iterations', [5, 10, 20]), 'seed': trial.suggest_int('seed', 1, 40), 'batch_size': trial.suggest_categorical('batch_size', [4, 8, 16, 32, 64])}

def load_data_splits(dataset: str, sample_sizes: List[int], add_data_augmentation: bool=False) -> Tuple[DatasetDict, Dataset]:
    print(f'\n\n\n============== {dataset} ============')
    train_split = load_dataset(f'SetFit/{dataset}', split='train')
    train_splits = create_fewshot_splits(train_split, sample_sizes, add_data_augmentation, f'SetFit/{dataset}')
    test_split = load_dataset(f'SetFit/{dataset}', split='test')
    print(f'Test set: {len(test_split)}')
    return (train_splits, test_split)

def load_data_splits_multilabel(dataset: str, sample_sizes: List[int]) -> Tuple[DatasetDict, Dataset]:
    print(f'\n\n\n============== {dataset} ============')
    train_split = load_dataset(f'SetFit/{dataset}', 'multilabel', split='train')
    train_splits = create_fewshot_splits_multilabel(train_split, sample_sizes)
    test_split = load_dataset(f'SetFit/{dataset}', 'multilabel', split='test')
    print(f'Test set: {len(test_split)}')
    return (train_splits, test_split)

@dataclass
class Benchmark:
    out_path: Optional[str] = None
    summary_msg: str = field(default_factory=str)

    def print(self, msg: str) -> None:
        print(msg)
        if self.out_path is not None:
            with open(self.out_path, 'a+') as f:
                f.write(msg + '\n')

    @contextmanager
    def track(self, step):
        start = monotonic_ns()
        yield
        ns = monotonic_ns() - start
        msg = f"\n{'*' * 70}\n'{step}' took {ns / SEC_TO_NS_SCALE:.3f}s ({ns:,}ns)\n{'*' * 70}\n"
        print(msg)
        self.summary_msg += msg + '\n'

    def summary(self) -> None:
        self.print(f"\n{'#' * 30}\nBenchmark Summary:\n{'#' * 30}\n\n{self.summary_msg}")

class BestRun(NamedTuple):
    run_id: str
    objective: float
    hyperparameters: Dict[str, Any]
    backend: Any = None

def set_docstring(method, docstring, cls=None):
    copied_function = copy_func(method)
    copied_function.__doc__ = docstring
    return types.MethodType(copied_function, cls or method.__self__)