diff --git "a/huggingface_setfit.txt" "b/huggingface_setfit.txt"
new file mode 100644--- /dev/null
+++ "b/huggingface_setfit.txt"
@@ -0,0 +1,2437 @@
+# 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'{repr(text)}')
+ 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': '' + ''.join(example_set) + '
'} 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__)
+