# File: autotrain-advanced-main/src/autotrain/__init__.py
import os
os.environ['BITSANDBYTES_NOWELCOME'] = '1'
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
os.environ['TOKENIZERS_PARALLELISM'] = 'false'
import warnings
import torch._dynamo
from autotrain.logging import Logger
torch._dynamo.config.suppress_errors = True
warnings.filterwarnings('ignore', category=UserWarning, module='tensorflow')
warnings.filterwarnings('ignore', category=UserWarning, module='transformers')
warnings.filterwarnings('ignore', category=UserWarning, module='peft')
warnings.filterwarnings('ignore', category=UserWarning, module='accelerate')
warnings.filterwarnings('ignore', category=UserWarning, module='datasets')
warnings.filterwarnings('ignore', category=FutureWarning, module='accelerate')
warnings.filterwarnings('ignore', category=UserWarning, module='huggingface_hub')
logger = Logger().get_logger()
__version__ = '0.8.19'

def is_colab():
    try:
        import google.colab
        return True
    except ImportError:
        return False

def is_unsloth_available():
    try:
        from unsloth import FastLanguageModel
        return True
    except Exception as e:
        logger.warning('Unsloth not available, continuing without it')
        logger.warning(e)
        return False

# File: autotrain-advanced-main/src/autotrain/app/api_routes.py
import json
from typing import Any, Dict, List, Literal, Optional, Tuple, Union, get_type_hints
from fastapi import APIRouter, Depends, HTTPException, Request, status
from fastapi.responses import JSONResponse
from huggingface_hub import HfApi
from pydantic import BaseModel, create_model, model_validator
from autotrain import __version__, logger
from autotrain.app.params import HIDDEN_PARAMS, PARAMS, AppParams
from autotrain.app.utils import token_verification
from autotrain.project import AutoTrainProject
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams
from autotrain.trainers.extractive_question_answering.params import ExtractiveQuestionAnsweringParams
from autotrain.trainers.image_classification.params import ImageClassificationParams
from autotrain.trainers.image_regression.params import ImageRegressionParams
from autotrain.trainers.sent_transformers.params import SentenceTransformersParams
from autotrain.trainers.seq2seq.params import Seq2SeqParams
from autotrain.trainers.tabular.params import TabularParams
from autotrain.trainers.text_classification.params import TextClassificationParams
from autotrain.trainers.text_regression.params import TextRegressionParams
from autotrain.trainers.token_classification.params import TokenClassificationParams
from autotrain.trainers.vlm.params import VLMTrainingParams
FIELDS_TO_EXCLUDE = HIDDEN_PARAMS + ['push_to_hub']

def create_api_base_model(base_class, class_name):
    annotations = get_type_hints(base_class)
    if class_name in ('LLMSFTTrainingParamsAPI', 'LLMRewardTrainingParamsAPI'):
        more_hidden_params = ['model_ref', 'dpo_beta', 'add_eos_token', 'max_prompt_length', 'max_completion_length']
    elif class_name == 'LLMORPOTrainingParamsAPI':
        more_hidden_params = ['model_ref', 'dpo_beta', 'add_eos_token']
    elif class_name == 'LLMDPOTrainingParamsAPI':
        more_hidden_params = ['add_eos_token']
    elif class_name == 'LLMGenericTrainingParamsAPI':
        more_hidden_params = ['model_ref', 'dpo_beta', 'max_prompt_length', 'max_completion_length']
    else:
        more_hidden_params = []
    _excluded = FIELDS_TO_EXCLUDE + more_hidden_params
    new_fields: Dict[str, Tuple[Any, Any]] = {}
    for (name, field) in base_class.__fields__.items():
        if name not in _excluded:
            field_type = annotations[name]
            if field.default is not None:
                field_default = field.default
            elif field.default_factory is not None:
                field_default = field.default_factory
            else:
                field_default = None
            new_fields[name] = (field_type, field_default)
    return create_model(class_name, **{key: (value[0], value[1]) for (key, value) in new_fields.items()}, __config__=type('Config', (), {'protected_namespaces': ()}))
LLMSFTTrainingParamsAPI = create_api_base_model(LLMTrainingParams, 'LLMSFTTrainingParamsAPI')
LLMDPOTrainingParamsAPI = create_api_base_model(LLMTrainingParams, 'LLMDPOTrainingParamsAPI')
LLMORPOTrainingParamsAPI = create_api_base_model(LLMTrainingParams, 'LLMORPOTrainingParamsAPI')
LLMGenericTrainingParamsAPI = create_api_base_model(LLMTrainingParams, 'LLMGenericTrainingParamsAPI')
LLMRewardTrainingParamsAPI = create_api_base_model(LLMTrainingParams, 'LLMRewardTrainingParamsAPI')
DreamBoothTrainingParamsAPI = create_api_base_model(DreamBoothTrainingParams, 'DreamBoothTrainingParamsAPI')
ImageClassificationParamsAPI = create_api_base_model(ImageClassificationParams, 'ImageClassificationParamsAPI')
Seq2SeqParamsAPI = create_api_base_model(Seq2SeqParams, 'Seq2SeqParamsAPI')
TabularClassificationParamsAPI = create_api_base_model(TabularParams, 'TabularClassificationParamsAPI')
TabularRegressionParamsAPI = create_api_base_model(TabularParams, 'TabularRegressionParamsAPI')
TextClassificationParamsAPI = create_api_base_model(TextClassificationParams, 'TextClassificationParamsAPI')
TextRegressionParamsAPI = create_api_base_model(TextRegressionParams, 'TextRegressionParamsAPI')
TokenClassificationParamsAPI = create_api_base_model(TokenClassificationParams, 'TokenClassificationParamsAPI')
SentenceTransformersParamsAPI = create_api_base_model(SentenceTransformersParams, 'SentenceTransformersParamsAPI')
ImageRegressionParamsAPI = create_api_base_model(ImageRegressionParams, 'ImageRegressionParamsAPI')
VLMTrainingParamsAPI = create_api_base_model(VLMTrainingParams, 'VLMTrainingParamsAPI')
ExtractiveQuestionAnsweringParamsAPI = create_api_base_model(ExtractiveQuestionAnsweringParams, 'ExtractiveQuestionAnsweringParamsAPI')

class LLMSFTColumnMapping(BaseModel):
    text_column: str

class LLMDPOColumnMapping(BaseModel):
    text_column: str
    rejected_text_column: str
    prompt_text_column: str

class LLMORPOColumnMapping(BaseModel):
    text_column: str
    rejected_text_column: str
    prompt_text_column: str

class LLMGenericColumnMapping(BaseModel):
    text_column: str

class LLMRewardColumnMapping(BaseModel):
    text_column: str
    rejected_text_column: str

class DreamBoothColumnMapping(BaseModel):
    default: Optional[str] = None

class ImageClassificationColumnMapping(BaseModel):
    image_column: str
    target_column: str

class ImageRegressionColumnMapping(BaseModel):
    image_column: str
    target_column: str

class Seq2SeqColumnMapping(BaseModel):
    text_column: str
    target_column: str

class TabularClassificationColumnMapping(BaseModel):
    id_column: str
    target_columns: List[str]

class TabularRegressionColumnMapping(BaseModel):
    id_column: str
    target_columns: List[str]

class TextClassificationColumnMapping(BaseModel):
    text_column: str
    target_column: str

class TextRegressionColumnMapping(BaseModel):
    text_column: str
    target_column: str

class TokenClassificationColumnMapping(BaseModel):
    tokens_column: str
    tags_column: str

class STPairColumnMapping(BaseModel):
    sentence1_column: str
    sentence2_column: str

class STPairClassColumnMapping(BaseModel):
    sentence1_column: str
    sentence2_column: str
    target_column: str

class STPairScoreColumnMapping(BaseModel):
    sentence1_column: str
    sentence2_column: str
    target_column: str

class STTripletColumnMapping(BaseModel):
    sentence1_column: str
    sentence2_column: str
    sentence3_column: str

class STQAColumnMapping(BaseModel):
    sentence1_column: str
    sentence2_column: str

class VLMColumnMapping(BaseModel):
    image_column: str
    text_column: str
    prompt_text_column: str

class ExtractiveQuestionAnsweringColumnMapping(BaseModel):
    text_column: str
    question_column: str
    answer_column: str

class APICreateProjectModel(BaseModel):
    project_name: str
    task: Literal['llm:sft', 'llm:dpo', 'llm:orpo', 'llm:generic', 'llm:reward', 'st:pair', 'st:pair_class', 'st:pair_score', 'st:triplet', 'st:qa', 'image-classification', 'dreambooth', 'seq2seq', 'token-classification', 'text-classification', 'text-regression', 'tabular-classification', 'tabular-regression', 'image-regression', 'vlm:captioning', 'vlm:vqa', 'extractive-question-answering']
    base_model: str
    hardware: Literal['spaces-a10g-large', 'spaces-a10g-small', 'spaces-a100-large', 'spaces-t4-medium', 'spaces-t4-small', 'spaces-cpu-upgrade', 'spaces-cpu-basic', 'spaces-l4x1', 'spaces-l4x4', 'spaces-l40sx1', 'spaces-l40sx4', 'spaces-l40sx8', 'spaces-a10g-largex2', 'spaces-a10g-largex4']
    params: Union[LLMSFTTrainingParamsAPI, LLMDPOTrainingParamsAPI, LLMORPOTrainingParamsAPI, LLMGenericTrainingParamsAPI, LLMRewardTrainingParamsAPI, SentenceTransformersParamsAPI, DreamBoothTrainingParamsAPI, ImageClassificationParamsAPI, Seq2SeqParamsAPI, TabularClassificationParamsAPI, TabularRegressionParamsAPI, TextClassificationParamsAPI, TextRegressionParamsAPI, TokenClassificationParamsAPI, ImageRegressionParamsAPI, VLMTrainingParamsAPI, ExtractiveQuestionAnsweringParamsAPI]
    username: str
    column_mapping: Optional[Union[LLMSFTColumnMapping, LLMDPOColumnMapping, LLMORPOColumnMapping, LLMGenericColumnMapping, LLMRewardColumnMapping, DreamBoothColumnMapping, ImageClassificationColumnMapping, Seq2SeqColumnMapping, TabularClassificationColumnMapping, TabularRegressionColumnMapping, TextClassificationColumnMapping, TextRegressionColumnMapping, TokenClassificationColumnMapping, STPairColumnMapping, STPairClassColumnMapping, STPairScoreColumnMapping, STTripletColumnMapping, STQAColumnMapping, ImageRegressionColumnMapping, VLMColumnMapping, ExtractiveQuestionAnsweringColumnMapping]] = None
    hub_dataset: str
    train_split: str
    valid_split: Optional[str] = None

    @model_validator(mode='before')
    @classmethod
    def validate_column_mapping(cls, values):
        if values.get('task') == 'llm:sft':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for llm:sft')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for llm:sft')
            values['column_mapping'] = LLMSFTColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'llm:dpo':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for llm:dpo')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for llm:dpo')
            if not values.get('column_mapping').get('rejected_text_column'):
                raise ValueError('rejected_text_column is required for llm:dpo')
            if not values.get('column_mapping').get('prompt_text_column'):
                raise ValueError('prompt_text_column is required for llm:dpo')
            values['column_mapping'] = LLMDPOColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'llm:orpo':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for llm:orpo')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for llm:orpo')
            if not values.get('column_mapping').get('rejected_text_column'):
                raise ValueError('rejected_text_column is required for llm:orpo')
            if not values.get('column_mapping').get('prompt_text_column'):
                raise ValueError('prompt_text_column is required for llm:orpo')
            values['column_mapping'] = LLMORPOColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'llm:generic':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for llm:generic')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for llm:generic')
            values['column_mapping'] = LLMGenericColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'llm:reward':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for llm:reward')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for llm:reward')
            if not values.get('column_mapping').get('rejected_text_column'):
                raise ValueError('rejected_text_column is required for llm:reward')
            values['column_mapping'] = LLMRewardColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'dreambooth':
            if values.get('column_mapping'):
                raise ValueError('column_mapping is not required for dreambooth')
        elif values.get('task') == 'seq2seq':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for seq2seq')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for seq2seq')
            if not values.get('column_mapping').get('target_column'):
                raise ValueError('target_column is required for seq2seq')
            values['column_mapping'] = Seq2SeqColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'image-classification':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for image-classification')
            if not values.get('column_mapping').get('image_column'):
                raise ValueError('image_column is required for image-classification')
            if not values.get('column_mapping').get('target_column'):
                raise ValueError('target_column is required for image-classification')
            values['column_mapping'] = ImageClassificationColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'tabular-classification':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for tabular-classification')
            if not values.get('column_mapping').get('id_column'):
                raise ValueError('id_column is required for tabular-classification')
            if not values.get('column_mapping').get('target_columns'):
                raise ValueError('target_columns is required for tabular-classification')
            values['column_mapping'] = TabularClassificationColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'tabular-regression':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for tabular-regression')
            if not values.get('column_mapping').get('id_column'):
                raise ValueError('id_column is required for tabular-regression')
            if not values.get('column_mapping').get('target_columns'):
                raise ValueError('target_columns is required for tabular-regression')
            values['column_mapping'] = TabularRegressionColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'text-classification':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for text-classification')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for text-classification')
            if not values.get('column_mapping').get('target_column'):
                raise ValueError('target_column is required for text-classification')
            values['column_mapping'] = TextClassificationColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'text-regression':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for text-regression')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for text-regression')
            if not values.get('column_mapping').get('target_column'):
                raise ValueError('target_column is required for text-regression')
            values['column_mapping'] = TextRegressionColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'token-classification':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for token-classification')
            if not values.get('column_mapping').get('tokens_column'):
                raise ValueError('tokens_column is required for token-classification')
            if not values.get('column_mapping').get('tags_column'):
                raise ValueError('tags_column is required for token-classification')
            values['column_mapping'] = TokenClassificationColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'st:pair':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for st:pair')
            if not values.get('column_mapping').get('sentence1_column'):
                raise ValueError('sentence1_column is required for st:pair')
            if not values.get('column_mapping').get('sentence2_column'):
                raise ValueError('sentence2_column is required for st:pair')
            values['column_mapping'] = STPairColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'st:pair_class':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for st:pair_class')
            if not values.get('column_mapping').get('sentence1_column'):
                raise ValueError('sentence1_column is required for st:pair_class')
            if not values.get('column_mapping').get('sentence2_column'):
                raise ValueError('sentence2_column is required for st:pair_class')
            if not values.get('column_mapping').get('target_column'):
                raise ValueError('target_column is required for st:pair_class')
            values['column_mapping'] = STPairClassColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'st:pair_score':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for st:pair_score')
            if not values.get('column_mapping').get('sentence1_column'):
                raise ValueError('sentence1_column is required for st:pair_score')
            if not values.get('column_mapping').get('sentence2_column'):
                raise ValueError('sentence2_column is required for st:pair_score')
            if not values.get('column_mapping').get('target_column'):
                raise ValueError('target_column is required for st:pair_score')
            values['column_mapping'] = STPairScoreColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'st:triplet':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for st:triplet')
            if not values.get('column_mapping').get('sentence1_column'):
                raise ValueError('sentence1_column is required for st:triplet')
            if not values.get('column_mapping').get('sentence2_column'):
                raise ValueError('sentence2_column is required for st:triplet')
            if not values.get('column_mapping').get('sentence3_column'):
                raise ValueError('sentence3_column is required for st:triplet')
            values['column_mapping'] = STTripletColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'st:qa':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for st:qa')
            if not values.get('column_mapping').get('sentence1_column'):
                raise ValueError('sentence1_column is required for st:qa')
            if not values.get('column_mapping').get('sentence2_column'):
                raise ValueError('sentence2_column is required for st:qa')
            values['column_mapping'] = STQAColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'image-regression':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for image-regression')
            if not values.get('column_mapping').get('image_column'):
                raise ValueError('image_column is required for image-regression')
            if not values.get('column_mapping').get('target_column'):
                raise ValueError('target_column is required for image-regression')
            values['column_mapping'] = ImageRegressionColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'vlm:captioning':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for vlm:captioning')
            if not values.get('column_mapping').get('image_column'):
                raise ValueError('image_column is required for vlm:captioning')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for vlm:captioning')
            if not values.get('column_mapping').get('prompt_text_column'):
                raise ValueError('prompt_text_column is required for vlm:captioning')
            values['column_mapping'] = VLMColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'vlm:vqa':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for vlm:vqa')
            if not values.get('column_mapping').get('image_column'):
                raise ValueError('image_column is required for vlm:vqa')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for vlm:vqa')
            if not values.get('column_mapping').get('prompt_text_column'):
                raise ValueError('prompt_text_column is required for vlm:vqa')
            values['column_mapping'] = VLMColumnMapping(**values['column_mapping'])
        elif values.get('task') == 'extractive-question-answering':
            if not values.get('column_mapping'):
                raise ValueError('column_mapping is required for extractive-question-answering')
            if not values.get('column_mapping').get('text_column'):
                raise ValueError('text_column is required for extractive-question-answering')
            if not values.get('column_mapping').get('question_column'):
                raise ValueError('question_column is required for extractive-question-answering')
            if not values.get('column_mapping').get('answer_column'):
                raise ValueError('answer_column is required for extractive-question-answering')
            values['column_mapping'] = ExtractiveQuestionAnsweringColumnMapping(**values['column_mapping'])
        return values

    @model_validator(mode='before')
    @classmethod
    def validate_params(cls, values):
        if values.get('task') == 'llm:sft':
            values['params'] = LLMSFTTrainingParamsAPI(**values['params'])
        elif values.get('task') == 'llm:dpo':
            values['params'] = LLMDPOTrainingParamsAPI(**values['params'])
        elif values.get('task') == 'llm:orpo':
            values['params'] = LLMORPOTrainingParamsAPI(**values['params'])
        elif values.get('task') == 'llm:generic':
            values['params'] = LLMGenericTrainingParamsAPI(**values['params'])
        elif values.get('task') == 'llm:reward':
            values['params'] = LLMRewardTrainingParamsAPI(**values['params'])
        elif values.get('task') == 'dreambooth':
            values['params'] = DreamBoothTrainingParamsAPI(**values['params'])
        elif values.get('task') == 'seq2seq':
            values['params'] = Seq2SeqParamsAPI(**values['params'])
        elif values.get('task') == 'image-classification':
            values['params'] = ImageClassificationParamsAPI(**values['params'])
        elif values.get('task') == 'tabular-classification':
            values['params'] = TabularClassificationParamsAPI(**values['params'])
        elif values.get('task') == 'tabular-regression':
            values['params'] = TabularRegressionParamsAPI(**values['params'])
        elif values.get('task') == 'text-classification':
            values['params'] = TextClassificationParamsAPI(**values['params'])
        elif values.get('task') == 'text-regression':
            values['params'] = TextRegressionParamsAPI(**values['params'])
        elif values.get('task') == 'token-classification':
            values['params'] = TokenClassificationParamsAPI(**values['params'])
        elif values.get('task').startswith('st:'):
            values['params'] = SentenceTransformersParamsAPI(**values['params'])
        elif values.get('task') == 'image-regression':
            values['params'] = ImageRegressionParamsAPI(**values['params'])
        elif values.get('task').startswith('vlm:'):
            values['params'] = VLMTrainingParamsAPI(**values['params'])
        elif values.get('task') == 'extractive-question-answering':
            values['params'] = ExtractiveQuestionAnsweringParamsAPI(**values['params'])
        return values
api_router = APIRouter()

def api_auth(request: Request):
    authorization = request.headers.get('Authorization')
    if authorization:
        (schema, _, token) = authorization.partition(' ')
        if schema.lower() == 'bearer':
            token = token.strip()
            try:
                _ = token_verification(token=token)
                return token
            except Exception as e:
                logger.error(f'Failed to verify token: {e}')
                raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail='Invalid or expired token: Bearer')
    raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail='Invalid or expired token')

@api_router.post('/create_project', response_class=JSONResponse)
async def api_create_project(project: APICreateProjectModel, token: bool=Depends(api_auth)):
    provided_params = project.params.model_dump()
    if project.hardware == 'local':
        hardware = 'local-ui'
    else:
        hardware = project.hardware
    logger.info(provided_params)
    logger.info(project.column_mapping)
    task = project.task
    if task.startswith('llm'):
        params = PARAMS['llm']
        trainer = task.split(':')[1]
        params.update({'trainer': trainer})
    elif task.startswith('st:'):
        params = PARAMS['st']
        trainer = task.split(':')[1]
        params.update({'trainer': trainer})
    elif task.startswith('vlm:'):
        params = PARAMS['vlm']
        trainer = task.split(':')[1]
        params.update({'trainer': trainer})
    elif task.startswith('tabular'):
        params = PARAMS['tabular']
    else:
        params = PARAMS[task]
    params.update(provided_params)
    app_params = AppParams(job_params_json=json.dumps(params), token=token, project_name=project.project_name, username=project.username, task=task, data_path=project.hub_dataset, base_model=project.base_model, column_mapping=project.column_mapping.model_dump() if project.column_mapping else None, using_hub_dataset=True, train_split=project.train_split, valid_split=project.valid_split, api=True)
    params = app_params.munge()
    project = AutoTrainProject(params=params, backend=hardware)
    job_id = project.create()
    return {'message': 'Project created', 'job_id': job_id, 'success': True}

@api_router.get('/version', response_class=JSONResponse)
async def api_version():
    return {'version': __version__}

@api_router.get('/logs', response_class=JSONResponse)
async def api_logs(job_id: str, token: bool=Depends(api_auth)):
    return {'logs': 'Not implemented yet', 'success': False, 'message': 'Not implemented yet'}

@api_router.get('/stop_training', response_class=JSONResponse)
async def api_stop_training(job_id: str, token: bool=Depends(api_auth)):
    hf_api = HfApi(token=token)
    try:
        hf_api.pause_space(repo_id=job_id)
    except Exception as e:
        logger.error(f'Failed to stop training: {e}')
        return {'message': f'Failed to stop training for {job_id}: {e}', 'success': False}
    return {'message': f'Training stopped for {job_id}', 'success': True}

# File: autotrain-advanced-main/src/autotrain/app/app.py
import os
from fastapi import FastAPI, Request
from fastapi.responses import RedirectResponse
from fastapi.staticfiles import StaticFiles
from autotrain import __version__, logger
from autotrain.app.api_routes import api_router
from autotrain.app.oauth import attach_oauth
from autotrain.app.ui_routes import ui_router
logger.info('Starting AutoTrain...')
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
app = FastAPI()
if 'SPACE_ID' in os.environ:
    attach_oauth(app)
app.include_router(ui_router, prefix='/ui', include_in_schema=False)
app.include_router(api_router, prefix='/api')
static_path = os.path.join(BASE_DIR, 'static')
app.mount('/static', StaticFiles(directory=static_path), name='static')
logger.info(f'AutoTrain version: {__version__}')
logger.info('AutoTrain started successfully')

@app.get('/')
async def forward_to_ui(request: Request):
    query_params = request.query_params
    url = '/ui/'
    if query_params:
        url += f'?{query_params}'
    return RedirectResponse(url=url)

# File: autotrain-advanced-main/src/autotrain/app/colab.py
import json
import os
import random
import string
import subprocess
import ipywidgets as widgets
import yaml
from autotrain.app.models import fetch_models
from autotrain.app.params import get_task_params

def generate_random_string():
    prefix = 'autotrain'
    part1 = ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
    part2 = ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
    return f'{prefix}-{part1}-{part2}'

def colab_app():
    if not os.path.exists('data'):
        os.makedirs('data')
    MODEL_CHOICES = fetch_models()
    TASK_NAMES = ['LLM SFT', 'LLM ORPO', 'LLM Generic', 'LLM DPO', 'LLM Reward', 'Text Classification', 'Text Regression', 'Sequence to Sequence', 'Token Classification', 'DreamBooth LoRA', 'Image Classification', 'Image Regression', 'Object Detection', 'Tabular Classification', 'Tabular Regression', 'ST Pair', 'ST Pair Classification', 'ST Pair Scoring', 'ST Triplet', 'ST Question Answering']
    TASK_MAP = {'LLM SFT': 'llm:sft', 'LLM ORPO': 'llm:orpo', 'LLM Generic': 'llm:generic', 'LLM DPO': 'llm:dpo', 'LLM Reward': 'llm:reward', 'Text Classification': 'text-classification', 'Text Regression': 'text-regression', 'Sequence to Sequence': 'seq2seq', 'Token Classification': 'token-classification', 'DreamBooth LoRA': 'dreambooth', 'Image Classification': 'image-classification', 'Image Regression': 'image-regression', 'Object Detection': 'image-object-detection', 'Tabular Classification': 'tabular:classification', 'Tabular Regression': 'tabular:regression', 'ST Pair': 'st:pair', 'ST Pair Classification': 'st:pair_class', 'ST Pair Scoring': 'st:pair_score', 'ST Triplet': 'st:triplet', 'ST Question Answering': 'st:qa'}

    def _get_params(task, param_type):
        _p = get_task_params(task, param_type=param_type)
        _p['push_to_hub'] = True
        _p = json.dumps(_p, indent=4)
        return _p
    hf_token_label = widgets.HTML("<h5 style='margin-bottom: 0; margin-top: 0;'>Hugging Face Write Token</h5>")
    hf_token = widgets.Password(value='', description='', disabled=False, layout=widgets.Layout(margin='0 0 0 0', width='200px'))
    hf_user_label = widgets.HTML("<h5 style='margin-bottom: 0; margin-top: 0;'>Hugging Face Username</h5>")
    hf_user = widgets.Text(value='', description='', disabled=False, layout=widgets.Layout(margin='0 0 0 0', width='200px'))
    base_model_label = widgets.HTML("<h5 style='margin-bottom: 0; margin-top: 0;'>Base Model</h5>")
    base_model = widgets.Text(value=MODEL_CHOICES['llm'][0], disabled=False, layout=widgets.Layout(width='420px'))
    project_name_label = widgets.HTML("<h5 style='margin-bottom: 0; margin-top: 0;'>Project Name</h5>")
    project_name = widgets.Text(value=generate_random_string(), description='', disabled=False, layout=widgets.Layout(margin='0 0 0 0', width='200px'))
    task_dropdown_label = widgets.HTML("<h5 style='margin-bottom: 0; margin-top: 0;'>Task</h5>")
    task_dropdown = widgets.Dropdown(options=TASK_NAMES, value=TASK_NAMES[0], description='', disabled=False, layout=widgets.Layout(margin='0 0 0 0', width='200px'))
    dataset_path_label = widgets.HTML("<h5 style='margin-bottom: 0; margin-top: 0;'>Path</h5>")
    dataset_path = widgets.Text(value='', description='', disabled=False, layout=widgets.Layout(margin='0 0 0 0', width='200px'))
    train_split_label = widgets.HTML("<h5 style='margin-bottom: 0; margin-top: 0;'>Train Split</h5>")
    train_split = widgets.Text(value='', description='', disabled=False, layout=widgets.Layout(margin='0 0 0 0', width='200px'))
    valid_split_label = widgets.HTML("<h5 style='margin-bottom: 0; margin-top: 0;'>Valid Split</h5>")
    valid_split = widgets.Text(value='', placeholder='optional', description='', disabled=False, layout=widgets.Layout(margin='0 0 0 0', width='200px'))
    dataset_source_dropdown_label = widgets.HTML("<h5 style='margin-bottom: 0; margin-top: 0;'>Source</h5>")
    dataset_source_dropdown = widgets.Dropdown(options=['Hugging Face Hub', 'Local'], value='Hugging Face Hub', description='', disabled=False, layout=widgets.Layout(margin='0 0 0 0', width='200px'))
    col_mapping_label = widgets.HTML("<h5 style='margin-bottom: 0; margin-top: 0;'>Column Mapping</h5>")
    col_mapping = widgets.Text(value='{"text": "text"}', placeholder='', description='', disabled=False, layout=widgets.Layout(margin='0 0 0 0', width='420px'))
    parameters_dropdown = widgets.Dropdown(options=['Basic', 'Full'], value='Basic', description='', disabled=False, layout=widgets.Layout(width='400px'))
    parameters = widgets.Textarea(value=_get_params('llm:sft', 'basic'), description='', disabled=False, layout=widgets.Layout(height='400px', width='400px'))
    start_training_button = widgets.Button(description='Start Training', layout=widgets.Layout(width='1000px'), disabled=False, button_style='', tooltip='Click to start training', icon='check')
    spacer = widgets.Box(layout=widgets.Layout(width='20px'))
    title_hbox0 = widgets.HTML('<h3>Hugging Face Credentials</h3>')
    title_hbox1 = widgets.HTML('<h3>Project Details</h3>')
    title_hbox2 = widgets.HTML('<h3>Dataset Details</h3>')
    title_hbox3 = widgets.HTML('<h3>Parameters</h3>')
    hbox0 = widgets.HBox([widgets.VBox([hf_token_label, hf_token]), spacer, widgets.VBox([hf_user_label, hf_user])])
    hbox1 = widgets.HBox([widgets.VBox([project_name_label, project_name]), spacer, widgets.VBox([task_dropdown_label, task_dropdown])])
    hbox2_1 = widgets.HBox([widgets.VBox([dataset_source_dropdown_label, dataset_source_dropdown]), spacer, widgets.VBox([dataset_path_label, dataset_path])])
    hbox2_2 = widgets.HBox([widgets.VBox([train_split_label, train_split]), spacer, widgets.VBox([valid_split_label, valid_split])])
    hbox2_3 = widgets.HBox([widgets.VBox([col_mapping_label, col_mapping])])
    hbox3 = widgets.VBox([parameters_dropdown, parameters])
    vbox0 = widgets.VBox([title_hbox0, hbox0])
    vbox1 = widgets.VBox([title_hbox1, base_model_label, base_model, hbox1])
    vbox2 = widgets.VBox([title_hbox2, hbox2_1, hbox2_2, hbox2_3])
    vbox3 = widgets.VBox([title_hbox3, hbox3])
    left_column = widgets.VBox([vbox0, vbox1, vbox2], layout=widgets.Layout(width='500px'))
    right_column = widgets.VBox([vbox3], layout=widgets.Layout(width='500px', align_items='flex-end'))
    separator = widgets.HTML('<div style="border-left: 1px solid black; height: 100%;"></div>')
    _main_layout = widgets.HBox([left_column, separator, right_column])
    main_layout = widgets.VBox([_main_layout, start_training_button])

    def on_dataset_change(change):
        if change['new'] == 'Local':
            dataset_path.value = 'data/'
            train_split.value = 'train'
            valid_split.value = ''
        else:
            dataset_path.value = ''
            train_split.value = ''
            valid_split.value = ''

    def update_parameters(*args):
        task = TASK_MAP[task_dropdown.value]
        param_type = parameters_dropdown.value.lower()
        parameters.value = _get_params(task, param_type)

    def update_col_mapping(*args):
        task = TASK_MAP[task_dropdown.value]
        if task in ['llm:sft', 'llm:generic']:
            col_mapping.value = '{"text": "text"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = True
        elif task in ['llm:dpo', 'llm:orpo']:
            col_mapping.value = '{"prompt": "prompt", "text": "text", "rejected_text": "rejected_text"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = True
        elif task == 'llm:reward':
            col_mapping.value = '{"text": "text", "rejected_text": "rejected_text"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = True
        elif task == 'text-classification':
            col_mapping.value = '{"text": "text", "label": "target"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'text-regression':
            col_mapping.value = '{"text": "text", "label": "target"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'token-classification':
            col_mapping.value = '{"text": "tokens", "label": "tags"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'seq2seq':
            col_mapping.value = '{"text": "text", "label": "target"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'dreambooth':
            col_mapping.value = '{"image": "image"}'
            dataset_source_dropdown.value = 'Local'
            dataset_source_dropdown.disabled = True
            valid_split.disabled = True
        elif task == 'image-classification':
            col_mapping.value = '{"image": "image", "label": "label"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'image-regression':
            col_mapping.value = '{"image": "image", "label": "target"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'image-object-detection':
            col_mapping.value = '{"image": "image", "objects": "objects"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'tabular:classification':
            col_mapping.value = '{"id": "id", "label": ["target"]}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'tabular:regression':
            col_mapping.value = '{"id": "id", "label": ["target"]}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'st:pair':
            col_mapping.value = '{"sentence1": "anchor", "sentence2": "positive"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'st:pair_class':
            col_mapping.value = '{"sentence1": "premise", "sentence2": "hypothesis", "target": "label"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'st:pair_score':
            col_mapping.value = '{"sentence1": "sentence1", "sentence2": "sentence2", "target": "score"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'st:triplet':
            col_mapping.value = '{"sentence1": "anchor", "sentence2": "positive", "sentence3": "negative"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        elif task == 'st:qa':
            col_mapping.value = '{"sentence1": "query", "sentence1": "answer"}'
            dataset_source_dropdown.disabled = False
            valid_split.disabled = False
        else:
            col_mapping.value = 'Enter column mapping...'

    def update_base_model(*args):
        if TASK_MAP[task_dropdown.value] == 'text-classification':
            base_model.value = MODEL_CHOICES['text-classification'][0]
        elif TASK_MAP[task_dropdown.value].startswith('llm'):
            base_model.value = MODEL_CHOICES['llm'][0]
        elif TASK_MAP[task_dropdown.value] == 'image-classification':
            base_model.value = MODEL_CHOICES['image-classification'][0]
        elif TASK_MAP[task_dropdown.value] == 'dreambooth':
            base_model.value = MODEL_CHOICES['dreambooth'][0]
        elif TASK_MAP[task_dropdown.value] == 'seq2seq':
            base_model.value = MODEL_CHOICES['seq2seq'][0]
        elif TASK_MAP[task_dropdown.value] == 'tabular:classification':
            base_model.value = MODEL_CHOICES['tabular-classification'][0]
        elif TASK_MAP[task_dropdown.value] == 'tabular:regression':
            base_model.value = MODEL_CHOICES['tabular-regression'][0]
        elif TASK_MAP[task_dropdown.value] == 'token-classification':
            base_model.value = MODEL_CHOICES['token-classification'][0]
        elif TASK_MAP[task_dropdown.value] == 'text-regression':
            base_model.value = MODEL_CHOICES['text-regression'][0]
        elif TASK_MAP[task_dropdown.value] == 'image-object-detection':
            base_model.value = MODEL_CHOICES['image-object-detection'][0]
        elif TASK_MAP[task_dropdown.value].startswith('st:'):
            base_model.value = MODEL_CHOICES['sentence-transformers'][0]
        else:
            base_model.value = 'Enter base model...'

    def start_training(b):
        start_training_button.disabled = True
        try:
            print('Training is starting... Please wait!')
            os.environ['HF_USERNAME'] = hf_user.value
            os.environ['HF_TOKEN'] = hf_token.value
            train_split_value = train_split.value.strip() if train_split.value.strip() != '' else None
            valid_split_value = valid_split.value.strip() if valid_split.value.strip() != '' else None
            params_val = json.loads(parameters.value)
            if task_dropdown.value.startswith('llm') or task_dropdown.value.startswith('sentence-transformers'):
                params_val['trainer'] = task_dropdown.value.split(':')[1]
            chat_template = params_val.get('chat_template')
            if chat_template is not None:
                params_val = {k: v for (k, v) in params_val.items() if k != 'chat_template'}
            if TASK_MAP[task_dropdown.value] == 'dreambooth':
                prompt = params_val.get('prompt')
                if prompt is None:
                    raise ValueError('Prompt is required for DreamBooth task')
                if not isinstance(prompt, str):
                    raise ValueError('Prompt should be a string')
                params_val = {k: v for (k, v) in params_val.items() if k != 'prompt'}
            else:
                prompt = None
            push_to_hub = params_val.get('push_to_hub', True)
            if 'push_to_hub' in params_val:
                params_val = {k: v for (k, v) in params_val.items() if k != 'push_to_hub'}
            if TASK_MAP[task_dropdown.value] != 'dreambooth':
                config = {'task': TASK_MAP[task_dropdown.value].split(':')[0], 'base_model': base_model.value, 'project_name': project_name.value, 'log': 'tensorboard', 'backend': 'local', 'data': {'path': dataset_path.value, 'train_split': train_split_value, 'valid_split': valid_split_value, 'column_mapping': json.loads(col_mapping.value)}, 'params': params_val, 'hub': {'username': '${{HF_USERNAME}}', 'token': '${{HF_TOKEN}}', 'push_to_hub': push_to_hub}}
                if TASK_MAP[task_dropdown.value].startswith('llm'):
                    config['data']['chat_template'] = chat_template
                    if config['data']['chat_template'] == 'none':
                        config['data']['chat_template'] = None
            else:
                config = {'task': TASK_MAP[task_dropdown.value], 'base_model': base_model.value, 'project_name': project_name.value, 'backend': 'local', 'data': {'path': dataset_path.value, 'prompt': prompt}, 'params': params_val, 'hub': {'username': '${HF_USERNAME}', 'token': '${HF_TOKEN}', 'push_to_hub': push_to_hub}}
            with open('config.yml', 'w') as f:
                yaml.dump(config, f)
            cmd = 'autotrain --config config.yml'
            process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
            while True:
                output = process.stdout.readline()
                if output == '' and process.poll() is not None:
                    break
                if output:
                    print(output.strip())
            poll_res = process.poll()
            if poll_res != 0:
                start_training_button.disabled = False
                raise Exception(f'Training failed with exit code: {poll_res}')
            print('Training completed successfully!')
            start_training_button.disabled = False
        except Exception as e:
            print('An error occurred while starting training!')
            print(f'Error: {e}')
            start_training_button.disabled = False
    start_training_button.on_click(start_training)
    dataset_source_dropdown.observe(on_dataset_change, names='value')
    task_dropdown.observe(update_col_mapping, names='value')
    task_dropdown.observe(update_parameters, names='value')
    task_dropdown.observe(update_base_model, names='value')
    parameters_dropdown.observe(update_parameters, names='value')
    return main_layout

# File: autotrain-advanced-main/src/autotrain/app/db.py
import sqlite3

class AutoTrainDB:

    def __init__(self, db_path):
        self.db_path = db_path
        self.conn = sqlite3.connect(db_path)
        self.c = self.conn.cursor()
        self.create_jobs_table()

    def create_jobs_table(self):
        self.c.execute('CREATE TABLE IF NOT EXISTS jobs\n            (id INTEGER PRIMARY KEY, pid INTEGER)')
        self.conn.commit()

    def add_job(self, pid):
        sql = f'INSERT INTO jobs (pid) VALUES ({pid})'
        self.c.execute(sql)
        self.conn.commit()

    def get_running_jobs(self):
        self.c.execute('SELECT pid FROM jobs')
        running_pids = self.c.fetchall()
        running_pids = [pid[0] for pid in running_pids]
        return running_pids

    def delete_job(self, pid):
        sql = f'DELETE FROM jobs WHERE pid={pid}'
        self.c.execute(sql)
        self.conn.commit()

# File: autotrain-advanced-main/src/autotrain/app/models.py
import collections
from huggingface_hub import list_models

def get_sorted_models(hub_models):
    hub_models = [{'id': m.id, 'downloads': m.downloads} for m in hub_models if m.private is False]
    hub_models = sorted(hub_models, key=lambda x: x['downloads'], reverse=True)
    hub_models = [m['id'] for m in hub_models]
    return hub_models

def _fetch_text_classification_models():
    hub_models1 = list(list_models(task='fill-mask', library='transformers', sort='downloads', direction=-1, limit=100, full=False))
    hub_models2 = list(list_models(task='text-classification', library='transformers', sort='downloads', direction=-1, limit=100, full=False))
    hub_models = list(hub_models1) + list(hub_models2)
    hub_models = get_sorted_models(hub_models)
    trending_models = list(list_models(task='fill-mask', library='transformers', sort='likes7d', direction=-1, limit=30, full=False))
    if len(trending_models) > 0:
        trending_models = get_sorted_models(trending_models)
        hub_models = [m for m in hub_models if m not in trending_models]
        hub_models = trending_models + hub_models
    return hub_models

def _fetch_llm_models():
    hub_models = list(list_models(task='text-generation', library='transformers', sort='downloads', direction=-1, limit=100, full=False))
    hub_models = get_sorted_models(hub_models)
    trending_models = list(list_models(task='text-generation', library='transformers', sort='likes7d', direction=-1, limit=30, full=False))
    if len(trending_models) > 0:
        trending_models = get_sorted_models(trending_models)
        hub_models = [m for m in hub_models if m not in trending_models]
        hub_models = trending_models + hub_models
    return hub_models

def _fetch_image_classification_models():
    hub_models = list(list_models(task='image-classification', library='transformers', sort='downloads', direction=-1, limit=100, full=False))
    hub_models = get_sorted_models(hub_models)
    trending_models = list(list_models(task='image-classification', library='transformers', sort='likes7d', direction=-1, limit=30, full=False))
    if len(trending_models) > 0:
        trending_models = get_sorted_models(trending_models)
        hub_models = [m for m in hub_models if m not in trending_models]
        hub_models = trending_models + hub_models
    return hub_models

def _fetch_image_object_detection_models():
    hub_models = list(list_models(task='object-detection', library='transformers', sort='downloads', direction=-1, limit=100, full=False, pipeline_tag='object-detection'))
    hub_models = get_sorted_models(hub_models)
    trending_models = list(list_models(task='object-detection', library='transformers', sort='likes7d', direction=-1, limit=30, full=False, pipeline_tag='object-detection'))
    if len(trending_models) > 0:
        trending_models = get_sorted_models(trending_models)
        hub_models = [m for m in hub_models if m not in trending_models]
        hub_models = trending_models + hub_models
    return hub_models

def _fetch_dreambooth_models():
    hub_models1 = list(list_models(task='text-to-image', sort='downloads', direction=-1, limit=100, full=False, filter=['diffusers:StableDiffusionXLPipeline']))
    hub_models2 = list(list_models(task='text-to-image', sort='downloads', direction=-1, limit=100, full=False, filter=['diffusers:StableDiffusionPipeline']))
    hub_models = list(hub_models1) + list(hub_models2)
    hub_models = get_sorted_models(hub_models)
    trending_models1 = list(list_models(task='text-to-image', sort='likes7d', direction=-1, limit=30, full=False, filter=['diffusers:StableDiffusionXLPipeline']))
    trending_models2 = list(list_models(task='text-to-image', sort='likes7d', direction=-1, limit=30, full=False, filter=['diffusers:StableDiffusionPipeline']))
    trending_models = list(trending_models1) + list(trending_models2)
    if len(trending_models) > 0:
        trending_models = get_sorted_models(trending_models)
        hub_models = [m for m in hub_models if m not in trending_models]
        hub_models = trending_models + hub_models
    return hub_models

def _fetch_seq2seq_models():
    hub_models = list(list_models(task='text2text-generation', library='transformers', sort='downloads', direction=-1, limit=100, full=False))
    hub_models = get_sorted_models(hub_models)
    trending_models = list(list_models(task='text2text-generation', library='transformers', sort='likes7d', direction=-1, limit=30, full=False))
    if len(trending_models) > 0:
        trending_models = get_sorted_models(trending_models)
        hub_models = [m for m in hub_models if m not in trending_models]
        hub_models = trending_models + hub_models
    return hub_models

def _fetch_token_classification_models():
    hub_models1 = list(list_models(task='fill-mask', library='transformers', sort='downloads', direction=-1, limit=100, full=False))
    hub_models2 = list(list_models(task='token-classification', library='transformers', sort='downloads', direction=-1, limit=100, full=False))
    hub_models = list(hub_models1) + list(hub_models2)
    hub_models = get_sorted_models(hub_models)
    trending_models = list(list_models(task='fill-mask', library='transformers', sort='likes7d', direction=-1, limit=30, full=False))
    if len(trending_models) > 0:
        trending_models = get_sorted_models(trending_models)
        hub_models = [m for m in hub_models if m not in trending_models]
        hub_models = trending_models + hub_models
    return hub_models

def _fetch_st_models():
    hub_models1 = list(list_models(task='sentence-similarity', library='sentence-transformers', sort='downloads', direction=-1, limit=30, full=False))
    hub_models2 = list(list_models(task='fill-mask', library='transformers', sort='downloads', direction=-1, limit=30, full=False))
    hub_models = list(hub_models1) + list(hub_models2)
    hub_models = get_sorted_models(hub_models)
    trending_models = list(list_models(task='sentence-similarity', library='sentence-transformers', sort='likes7d', direction=-1, limit=30, full=False))
    if len(trending_models) > 0:
        trending_models = get_sorted_models(trending_models)
        hub_models = [m for m in hub_models if m not in trending_models]
        hub_models = trending_models + hub_models
    return hub_models

def _fetch_vlm_models():
    hub_models1 = list(list_models(task='image-text-to-text', sort='downloads', direction=-1, limit=100, full=False, filter=['paligemma']))
    hub_models2 = []
    hub_models = list(hub_models1) + list(hub_models2)
    hub_models = get_sorted_models(hub_models)
    trending_models1 = list(list_models(task='image-text-to-text', sort='likes7d', direction=-1, limit=30, full=False, filter=['paligemma']))
    trending_models2 = []
    trending_models = list(trending_models1) + list(trending_models2)
    if len(trending_models) > 0:
        trending_models = get_sorted_models(trending_models)
        hub_models = [m for m in hub_models if m not in trending_models]
        hub_models = trending_models + hub_models
    return hub_models

def fetch_models():
    _mc = collections.defaultdict(list)
    _mc['text-classification'] = _fetch_text_classification_models()
    _mc['llm'] = _fetch_llm_models()
    _mc['image-classification'] = _fetch_image_classification_models()
    _mc['image-regression'] = _fetch_image_classification_models()
    _mc['dreambooth'] = _fetch_dreambooth_models()
    _mc['seq2seq'] = _fetch_seq2seq_models()
    _mc['token-classification'] = _fetch_token_classification_models()
    _mc['text-regression'] = _fetch_text_classification_models()
    _mc['image-object-detection'] = _fetch_image_object_detection_models()
    _mc['sentence-transformers'] = _fetch_st_models()
    _mc['vlm'] = _fetch_vlm_models()
    _mc['extractive-qa'] = _fetch_text_classification_models()
    _mc['tabular-classification'] = ['xgboost', 'random_forest', 'ridge', 'logistic_regression', 'svm', 'extra_trees', 'adaboost', 'decision_tree', 'knn']
    _mc['tabular-regression'] = ['xgboost', 'random_forest', 'ridge', 'svm', 'extra_trees', 'adaboost', 'decision_tree', 'knn']
    return _mc

# File: autotrain-advanced-main/src/autotrain/app/oauth.py
""""""
from __future__ import annotations
import hashlib
import os
import urllib.parse
import fastapi
from authlib.integrations.base_client.errors import MismatchingStateError
from authlib.integrations.starlette_client import OAuth
from fastapi.responses import RedirectResponse
from starlette.middleware.sessions import SessionMiddleware
OAUTH_CLIENT_ID = os.environ.get('OAUTH_CLIENT_ID')
OAUTH_CLIENT_SECRET = os.environ.get('OAUTH_CLIENT_SECRET')
OAUTH_SCOPES = os.environ.get('OAUTH_SCOPES')
OPENID_PROVIDER_URL = os.environ.get('OPENID_PROVIDER_URL')

def attach_oauth(app: fastapi.FastAPI):
    _add_oauth_routes(app)
    session_secret = OAUTH_CLIENT_SECRET + '-autotrain-v2'
    app.add_middleware(SessionMiddleware, secret_key=hashlib.sha256(session_secret.encode()).hexdigest(), https_only=True, same_site='none')

def _add_oauth_routes(app: fastapi.FastAPI) -> None:
    msg = "OAuth is required but {} environment variable is not set. Make sure you've enabled OAuth in your Space by setting `hf_oauth: true` in the Space metadata."
    if OAUTH_CLIENT_ID is None:
        raise ValueError(msg.format('OAUTH_CLIENT_ID'))
    if OAUTH_CLIENT_SECRET is None:
        raise ValueError(msg.format('OAUTH_CLIENT_SECRET'))
    if OAUTH_SCOPES is None:
        raise ValueError(msg.format('OAUTH_SCOPES'))
    if OPENID_PROVIDER_URL is None:
        raise ValueError(msg.format('OPENID_PROVIDER_URL'))
    oauth = OAuth()
    oauth.register(name='huggingface', client_id=OAUTH_CLIENT_ID, client_secret=OAUTH_CLIENT_SECRET, client_kwargs={'scope': OAUTH_SCOPES}, server_metadata_url=OPENID_PROVIDER_URL + '/.well-known/openid-configuration')

    @app.get('/login/huggingface')
    async def oauth_login(request: fastapi.Request):
        redirect_uri = request.url_for('auth')
        redirect_uri_as_str = str(redirect_uri)
        if redirect_uri.netloc.endswith('.hf.space'):
            redirect_uri_as_str = redirect_uri_as_str.replace('http://', 'https://')
        return await oauth.huggingface.authorize_redirect(request, redirect_uri_as_str)

    @app.get('/auth')
    async def auth(request: fastapi.Request) -> RedirectResponse:
        try:
            oauth_info = await oauth.huggingface.authorize_access_token(request)
        except MismatchingStateError:
            login_uri = '/login/huggingface'
            if '_target_url' in request.query_params:
                login_uri += '?' + urllib.parse.urlencode({'_target_url': request.query_params['_target_url']})
            for key in list(request.session.keys()):
                if key.startswith('_state_huggingface'):
                    request.session.pop(key)
            return RedirectResponse(login_uri)
        request.session['oauth_info'] = oauth_info
        return _redirect_to_target(request)

def _generate_redirect_uri(request: fastapi.Request) -> str:
    if '_target_url' in request.query_params:
        target = request.query_params['_target_url']
    else:
        target = '/?' + urllib.parse.urlencode(request.query_params)
    redirect_uri = request.url_for('oauth_redirect_callback').include_query_params(_target_url=target)
    redirect_uri_as_str = str(redirect_uri)
    if redirect_uri.netloc.endswith('.hf.space'):
        redirect_uri_as_str = redirect_uri_as_str.replace('http://', 'https://')
    return redirect_uri_as_str

def _redirect_to_target(request: fastapi.Request, default_target: str='/') -> RedirectResponse:
    target = request.query_params.get('_target_url', default_target)
    return RedirectResponse(target)

# File: autotrain-advanced-main/src/autotrain/app/params.py
import json
from dataclasses import dataclass
from typing import Optional
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams
from autotrain.trainers.extractive_question_answering.params import ExtractiveQuestionAnsweringParams
from autotrain.trainers.image_classification.params import ImageClassificationParams
from autotrain.trainers.image_regression.params import ImageRegressionParams
from autotrain.trainers.object_detection.params import ObjectDetectionParams
from autotrain.trainers.sent_transformers.params import SentenceTransformersParams
from autotrain.trainers.seq2seq.params import Seq2SeqParams
from autotrain.trainers.tabular.params import TabularParams
from autotrain.trainers.text_classification.params import TextClassificationParams
from autotrain.trainers.text_regression.params import TextRegressionParams
from autotrain.trainers.token_classification.params import TokenClassificationParams
from autotrain.trainers.vlm.params import VLMTrainingParams
HIDDEN_PARAMS = ['token', 'project_name', 'username', 'task', 'backend', 'train_split', 'valid_split', 'text_column', 'rejected_text_column', 'prompt_text_column', 'push_to_hub', 'trainer', 'model', 'data_path', 'image_path', 'class_image_path', 'revision', 'tokenizer', 'class_prompt', 'num_class_images', 'class_labels_conditioning', 'resume_from_checkpoint', 'dataloader_num_workers', 'allow_tf32', 'prior_generation_precision', 'local_rank', 'tokenizer_max_length', 'rank', 'xl', 'checkpoints_total_limit', 'validation_images', 'validation_epochs', 'num_validation_images', 'validation_prompt', 'sample_batch_size', 'log', 'image_column', 'target_column', 'id_column', 'target_columns', 'tokens_column', 'tags_column', 'objects_column', 'sentence1_column', 'sentence2_column', 'sentence3_column', 'question_column', 'answer_column']
PARAMS = {}
PARAMS['llm'] = LLMTrainingParams(target_modules='all-linear', log='tensorboard', mixed_precision='fp16', quantization='int4', peft=True, block_size=1024, epochs=3, padding='right', chat_template='none', max_completion_length=128).model_dump()
PARAMS['text-classification'] = TextClassificationParams(mixed_precision='fp16', log='tensorboard').model_dump()
PARAMS['st'] = SentenceTransformersParams(mixed_precision='fp16', log='tensorboard').model_dump()
PARAMS['image-classification'] = ImageClassificationParams(mixed_precision='fp16', log='tensorboard').model_dump()
PARAMS['image-object-detection'] = ObjectDetectionParams(mixed_precision='fp16', log='tensorboard').model_dump()
PARAMS['seq2seq'] = Seq2SeqParams(mixed_precision='fp16', target_modules='all-linear', log='tensorboard').model_dump()
PARAMS['tabular'] = TabularParams(categorical_imputer='most_frequent', numerical_imputer='median', numeric_scaler='robust').model_dump()
PARAMS['dreambooth'] = DreamBoothTrainingParams(prompt='<enter your prompt here>', vae_model='', num_steps=500, disable_gradient_checkpointing=False, mixed_precision='fp16', batch_size=1, gradient_accumulation=4, resolution=1024, use_8bit_adam=False, xformers=False, train_text_encoder=False, lr=0.0001).model_dump()
PARAMS['token-classification'] = TokenClassificationParams(mixed_precision='fp16', log='tensorboard').model_dump()
PARAMS['text-regression'] = TextRegressionParams(mixed_precision='fp16', log='tensorboard').model_dump()
PARAMS['image-regression'] = ImageRegressionParams(mixed_precision='fp16', log='tensorboard').model_dump()
PARAMS['vlm'] = VLMTrainingParams(mixed_precision='fp16', target_modules='all-linear', log='tensorboard', quantization='int4', peft=True, epochs=3).model_dump()
PARAMS['extractive-qa'] = ExtractiveQuestionAnsweringParams(mixed_precision='fp16', log='tensorboard', max_seq_length=512, max_doc_stride=128).model_dump()

@dataclass
class AppParams:
    job_params_json: str
    token: str
    project_name: str
    username: str
    task: str
    data_path: str
    base_model: str
    column_mapping: dict
    train_split: Optional[str] = None
    valid_split: Optional[str] = None
    using_hub_dataset: Optional[bool] = False
    api: Optional[bool] = False

    def __post_init__(self):
        if self.using_hub_dataset and (not self.train_split):
            raise ValueError('train_split is required when using a hub dataset')

    def munge(self):
        if self.task == 'text-classification':
            return self._munge_params_text_clf()
        elif self.task == 'seq2seq':
            return self._munge_params_seq2seq()
        elif self.task == 'image-classification':
            return self._munge_params_img_clf()
        elif self.task == 'image-object-detection':
            return self._munge_params_img_obj_det()
        elif self.task.startswith('tabular'):
            return self._munge_params_tabular()
        elif self.task == 'dreambooth':
            return self._munge_params_dreambooth()
        elif self.task.startswith('llm'):
            return self._munge_params_llm()
        elif self.task == 'token-classification':
            return self._munge_params_token_clf()
        elif self.task == 'text-regression':
            return self._munge_params_text_reg()
        elif self.task.startswith('st:'):
            return self._munge_params_sent_transformers()
        elif self.task == 'image-regression':
            return self._munge_params_img_reg()
        elif self.task.startswith('vlm'):
            return self._munge_params_vlm()
        elif self.task == 'extractive-qa':
            return self._munge_params_extractive_qa()
        else:
            raise ValueError(f'Unknown task: {self.task}')

    def _munge_common_params(self):
        _params = json.loads(self.job_params_json)
        _params['token'] = self.token
        _params['project_name'] = f'{self.project_name}'
        if 'push_to_hub' not in _params:
            _params['push_to_hub'] = True
        _params['data_path'] = self.data_path
        _params['username'] = self.username
        return _params

    def _munge_params_sent_transformers(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        _params['log'] = 'tensorboard'
        if not self.using_hub_dataset:
            _params['sentence1_column'] = 'autotrain_sentence1'
            _params['sentence2_column'] = 'autotrain_sentence2'
            _params['sentence3_column'] = 'autotrain_sentence3'
            _params['target_column'] = 'autotrain_target'
            _params['valid_split'] = 'validation'
        else:
            _params['sentence1_column'] = self.column_mapping.get('sentence1' if not self.api else 'sentence1_column', 'sentence1')
            _params['sentence2_column'] = self.column_mapping.get('sentence2' if not self.api else 'sentence2_column', 'sentence2')
            _params['sentence3_column'] = self.column_mapping.get('sentence3' if not self.api else 'sentence3_column', 'sentence3')
            _params['target_column'] = self.column_mapping.get('target' if not self.api else 'target_column', 'target')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
        trainer = self.task.split(':')[1]
        _params['trainer'] = trainer.lower()
        return SentenceTransformersParams(**_params)

    def _munge_params_llm(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        if not self.using_hub_dataset:
            _params['text_column'] = 'autotrain_text'
            _params['prompt_text_column'] = 'autotrain_prompt'
            _params['rejected_text_column'] = 'autotrain_rejected_text'
        else:
            _params['text_column'] = self.column_mapping.get('text' if not self.api else 'text_column', 'text')
            _params['prompt_text_column'] = self.column_mapping.get('prompt' if not self.api else 'prompt_text_column', 'prompt')
            _params['rejected_text_column'] = self.column_mapping.get('rejected_text' if not self.api else 'rejected_text_column', 'rejected_text')
            _params['train_split'] = self.train_split
        _params['log'] = 'tensorboard'
        trainer = self.task.split(':')[1]
        if trainer != 'generic':
            _params['trainer'] = trainer.lower()
        if 'quantization' in _params:
            if _params['quantization'] in ('none', 'no'):
                _params['quantization'] = None
        return LLMTrainingParams(**_params)

    def _munge_params_vlm(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        if not self.using_hub_dataset:
            _params['text_column'] = 'autotrain_text'
            _params['prompt_text_column'] = 'autotrain_prompt'
            _params['image_column'] = 'autotrain_image'
            _params['valid_split'] = 'validation'
        else:
            _params['text_column'] = self.column_mapping.get('text' if not self.api else 'text_column', 'text')
            _params['prompt_text_column'] = self.column_mapping.get('prompt' if not self.api else 'prompt_text_column', 'prompt')
            _params['image_column'] = self.column_mapping.get('image' if not self.api else 'rejected_text_column', 'image')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
        _params['log'] = 'tensorboard'
        trainer = self.task.split(':')[1]
        _params['trainer'] = trainer.lower()
        if 'quantization' in _params:
            if _params['quantization'] in ('none', 'no'):
                _params['quantization'] = None
        return VLMTrainingParams(**_params)

    def _munge_params_text_clf(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        _params['log'] = 'tensorboard'
        if not self.using_hub_dataset:
            _params['text_column'] = 'autotrain_text'
            _params['target_column'] = 'autotrain_label'
            _params['valid_split'] = 'validation'
        else:
            _params['text_column'] = self.column_mapping.get('text' if not self.api else 'text_column', 'text')
            _params['target_column'] = self.column_mapping.get('label' if not self.api else 'target_column', 'label')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
        return TextClassificationParams(**_params)

    def _munge_params_extractive_qa(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        _params['log'] = 'tensorboard'
        if not self.using_hub_dataset:
            _params['text_column'] = 'autotrain_text'
            _params['question_column'] = 'autotrain_question'
            _params['answer_column'] = 'autotrain_answer'
            _params['valid_split'] = 'validation'
        else:
            _params['text_column'] = self.column_mapping.get('text' if not self.api else 'text_column', 'text')
            _params['question_column'] = self.column_mapping.get('question' if not self.api else 'question_column', 'question')
            _params['answer_column'] = self.column_mapping.get('answer' if not self.api else 'answer_column', 'answer')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
        return ExtractiveQuestionAnsweringParams(**_params)

    def _munge_params_text_reg(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        _params['log'] = 'tensorboard'
        if not self.using_hub_dataset:
            _params['text_column'] = 'autotrain_text'
            _params['target_column'] = 'autotrain_label'
            _params['valid_split'] = 'validation'
        else:
            _params['text_column'] = self.column_mapping.get('text' if not self.api else 'text_column', 'text')
            _params['target_column'] = self.column_mapping.get('label' if not self.api else 'target_column', 'label')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
        return TextRegressionParams(**_params)

    def _munge_params_token_clf(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        _params['log'] = 'tensorboard'
        if not self.using_hub_dataset:
            _params['tokens_column'] = 'autotrain_text'
            _params['tags_column'] = 'autotrain_label'
            _params['valid_split'] = 'validation'
        else:
            _params['tokens_column'] = self.column_mapping.get('text' if not self.api else 'tokens_column', 'text')
            _params['tags_column'] = self.column_mapping.get('label' if not self.api else 'tags_column', 'label')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
        return TokenClassificationParams(**_params)

    def _munge_params_seq2seq(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        _params['log'] = 'tensorboard'
        if not self.using_hub_dataset:
            _params['text_column'] = 'autotrain_text'
            _params['target_column'] = 'autotrain_label'
            _params['valid_split'] = 'validation'
        else:
            _params['text_column'] = self.column_mapping.get('text' if not self.api else 'text_column', 'text')
            _params['target_column'] = self.column_mapping.get('label' if not self.api else 'target_column', 'label')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
        return Seq2SeqParams(**_params)

    def _munge_params_img_clf(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        _params['log'] = 'tensorboard'
        if not self.using_hub_dataset:
            _params['image_column'] = 'autotrain_image'
            _params['target_column'] = 'autotrain_label'
            _params['valid_split'] = 'validation'
        else:
            _params['image_column'] = self.column_mapping.get('image' if not self.api else 'image_column', 'image')
            _params['target_column'] = self.column_mapping.get('label' if not self.api else 'target_column', 'label')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
        return ImageClassificationParams(**_params)

    def _munge_params_img_reg(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        _params['log'] = 'tensorboard'
        if not self.using_hub_dataset:
            _params['image_column'] = 'autotrain_image'
            _params['target_column'] = 'autotrain_label'
            _params['valid_split'] = 'validation'
        else:
            _params['image_column'] = self.column_mapping.get('image' if not self.api else 'image_column', 'image')
            _params['target_column'] = self.column_mapping.get('target' if not self.api else 'target_column', 'target')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
        return ImageRegressionParams(**_params)

    def _munge_params_img_obj_det(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        _params['log'] = 'tensorboard'
        if not self.using_hub_dataset:
            _params['image_column'] = 'autotrain_image'
            _params['objects_column'] = 'autotrain_objects'
            _params['valid_split'] = 'validation'
        else:
            _params['image_column'] = self.column_mapping.get('image' if not self.api else 'image_column', 'image')
            _params['objects_column'] = self.column_mapping.get('objects' if not self.api else 'objects_column', 'objects')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
        return ObjectDetectionParams(**_params)

    def _munge_params_tabular(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        if not self.using_hub_dataset:
            _params['id_column'] = 'autotrain_id'
            _params['valid_split'] = 'validation'
            if len(self.column_mapping['label']) == 1:
                _params['target_columns'] = ['autotrain_label']
            else:
                _params['target_columns'] = ['autotrain_label_' + str(i) for i in range(len(self.column_mapping['label']))]
        else:
            _params['id_column'] = self.column_mapping.get('id' if not self.api else 'id_column', 'id')
            _params['train_split'] = self.train_split
            _params['valid_split'] = self.valid_split
            _params['target_columns'] = self.column_mapping.get('label' if not self.api else 'target_columns', 'label')
        if len(_params['categorical_imputer'].strip()) == 0 or _params['categorical_imputer'].lower() == 'none':
            _params['categorical_imputer'] = None
        if len(_params['numerical_imputer'].strip()) == 0 or _params['numerical_imputer'].lower() == 'none':
            _params['numerical_imputer'] = None
        if len(_params['numeric_scaler'].strip()) == 0 or _params['numeric_scaler'].lower() == 'none':
            _params['numeric_scaler'] = None
        if 'classification' in self.task:
            _params['task'] = 'classification'
        else:
            _params['task'] = 'regression'
        return TabularParams(**_params)

    def _munge_params_dreambooth(self):
        _params = self._munge_common_params()
        _params['model'] = self.base_model
        _params['image_path'] = self.data_path
        if 'weight_decay' in _params:
            _params['adam_weight_decay'] = _params['weight_decay']
            _params.pop('weight_decay')
        return DreamBoothTrainingParams(**_params)

def get_task_params(task, param_type):
    if task.startswith('llm'):
        trainer = task.split(':')[1].lower()
        task = task.split(':')[0].lower()
    if task.startswith('st:'):
        trainer = task.split(':')[1].lower()
        task = task.split(':')[0].lower()
    if task.startswith('vlm:'):
        trainer = task.split(':')[1].lower()
        task = task.split(':')[0].lower()
    if task.startswith('tabular'):
        task = 'tabular'
    if task not in PARAMS:
        return {}
    task_params = PARAMS[task]
    task_params = {k: v for (k, v) in task_params.items() if k not in HIDDEN_PARAMS}
    if task == 'llm':
        more_hidden_params = []
        if trainer == 'sft':
            more_hidden_params = ['model_ref', 'dpo_beta', 'add_eos_token', 'max_prompt_length', 'max_completion_length']
        elif trainer == 'reward':
            more_hidden_params = ['model_ref', 'dpo_beta', 'add_eos_token', 'max_prompt_length', 'max_completion_length', 'unsloth']
        elif trainer == 'orpo':
            more_hidden_params = ['model_ref', 'dpo_beta', 'add_eos_token', 'unsloth']
        elif trainer == 'generic':
            more_hidden_params = ['model_ref', 'dpo_beta', 'max_prompt_length', 'max_completion_length']
        elif trainer == 'dpo':
            more_hidden_params = ['add_eos_token', 'unsloth']
        if param_type == 'basic':
            more_hidden_params.extend(['padding', 'use_flash_attention_2', 'disable_gradient_checkpointing', 'logging_steps', 'eval_strategy', 'save_total_limit', 'auto_find_batch_size', 'warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'quantization', 'merge_adapter', 'lora_r', 'lora_alpha', 'lora_dropout', 'max_completion_length'])
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'text-classification' and param_type == 'basic':
        more_hidden_params = ['warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'logging_steps', 'auto_find_batch_size', 'save_total_limit', 'eval_strategy', 'early_stopping_patience', 'early_stopping_threshold']
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'extractive-qa' and param_type == 'basic':
        more_hidden_params = ['warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'logging_steps', 'auto_find_batch_size', 'save_total_limit', 'eval_strategy', 'early_stopping_patience', 'early_stopping_threshold']
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'st' and param_type == 'basic':
        more_hidden_params = ['warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'logging_steps', 'auto_find_batch_size', 'save_total_limit', 'eval_strategy', 'early_stopping_patience', 'early_stopping_threshold']
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'vlm' and param_type == 'basic':
        more_hidden_params = ['warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'logging_steps', 'auto_find_batch_size', 'save_total_limit', 'eval_strategy', 'early_stopping_patience', 'early_stopping_threshold', 'quantization', 'lora_r', 'lora_alpha', 'lora_dropout']
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'text-regression' and param_type == 'basic':
        more_hidden_params = ['warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'logging_steps', 'auto_find_batch_size', 'save_total_limit', 'eval_strategy', 'early_stopping_patience', 'early_stopping_threshold']
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'image-classification' and param_type == 'basic':
        more_hidden_params = ['warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'logging_steps', 'auto_find_batch_size', 'save_total_limit', 'eval_strategy', 'early_stopping_patience', 'early_stopping_threshold']
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'image-regression' and param_type == 'basic':
        more_hidden_params = ['warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'logging_steps', 'auto_find_batch_size', 'save_total_limit', 'eval_strategy', 'early_stopping_patience', 'early_stopping_threshold']
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'image-object-detection' and param_type == 'basic':
        more_hidden_params = ['warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'logging_steps', 'auto_find_batch_size', 'save_total_limit', 'eval_strategy', 'early_stopping_patience', 'early_stopping_threshold']
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'seq2seq' and param_type == 'basic':
        more_hidden_params = ['warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'logging_steps', 'auto_find_batch_size', 'save_total_limit', 'eval_strategy', 'quantization', 'lora_r', 'lora_alpha', 'lora_dropout', 'target_modules', 'early_stopping_patience', 'early_stopping_threshold']
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'token-classification' and param_type == 'basic':
        more_hidden_params = ['warmup_ratio', 'weight_decay', 'max_grad_norm', 'seed', 'logging_steps', 'auto_find_batch_size', 'save_total_limit', 'eval_strategy', 'early_stopping_patience', 'early_stopping_threshold']
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    if task == 'dreambooth':
        more_hidden_params = ['epochs', 'logging', 'bf16']
        if param_type == 'basic':
            more_hidden_params.extend(['prior_preservation', 'prior_loss_weight', 'seed', 'center_crop', 'train_text_encoder', 'disable_gradient_checkpointing', 'scale_lr', 'warmup_steps', 'num_cycles', 'lr_power', 'adam_beta1', 'adam_beta2', 'adam_weight_decay', 'adam_epsilon', 'max_grad_norm', 'pre_compute_text_embeddings', 'text_encoder_use_attention_mask'])
        task_params = {k: v for (k, v) in task_params.items() if k not in more_hidden_params}
    return task_params

# File: autotrain-advanced-main/src/autotrain/app/training_api.py
import asyncio
import os
import signal
import sys
from contextlib import asynccontextmanager
from fastapi import FastAPI
from autotrain import logger
from autotrain.app.db import AutoTrainDB
from autotrain.app.utils import get_running_jobs, kill_process_by_pid
from autotrain.utils import run_training
HF_TOKEN = os.environ.get('HF_TOKEN')
AUTOTRAIN_USERNAME = os.environ.get('AUTOTRAIN_USERNAME')
PROJECT_NAME = os.environ.get('PROJECT_NAME')
TASK_ID = int(os.environ.get('TASK_ID'))
PARAMS = os.environ.get('PARAMS')
DATA_PATH = os.environ.get('DATA_PATH')
MODEL = os.environ.get('MODEL')
DB = AutoTrainDB('autotrain.db')

def graceful_exit(signum, frame):
    logger.info('SIGTERM received. Performing cleanup...')
    sys.exit(0)
signal.signal(signal.SIGTERM, graceful_exit)

class BackgroundRunner:

    async def run_main(self):
        while True:
            running_jobs = get_running_jobs(DB)
            if not running_jobs:
                logger.info('No running jobs found. Shutting down the server.')
                kill_process_by_pid(os.getpid())
            await asyncio.sleep(30)
runner = BackgroundRunner()

@asynccontextmanager
async def lifespan(app: FastAPI):
    process_pid = run_training(params=PARAMS, task_id=TASK_ID)
    logger.info(f'Started training with PID {process_pid}')
    DB.add_job(process_pid)
    task = asyncio.create_task(runner.run_main())
    yield
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        logger.info('Background runner task cancelled.')
api = FastAPI(lifespan=lifespan)
logger.info(f'AUTOTRAIN_USERNAME: {AUTOTRAIN_USERNAME}')
logger.info(f'PROJECT_NAME: {PROJECT_NAME}')
logger.info(f'TASK_ID: {TASK_ID}')
logger.info(f'DATA_PATH: {DATA_PATH}')
logger.info(f'MODEL: {MODEL}')

@api.get('/')
async def root():
    return 'Your model is being trained...'

@api.get('/health')
async def health():
    return 'OK'

# File: autotrain-advanced-main/src/autotrain/app/ui_routes.py
import json
import os
import signal
import sys
import time
from typing import List
import torch
from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, Request, UploadFile, status
from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
from fastapi.templating import Jinja2Templates
from huggingface_hub import repo_exists
from nvitop import Device
from autotrain import __version__, logger
from autotrain.app.db import AutoTrainDB
from autotrain.app.models import fetch_models
from autotrain.app.params import AppParams, get_task_params
from autotrain.app.utils import get_running_jobs, get_user_and_orgs, kill_process_by_pid, token_verification
from autotrain.dataset import AutoTrainDataset, AutoTrainDreamboothDataset, AutoTrainImageClassificationDataset, AutoTrainImageRegressionDataset, AutoTrainObjectDetectionDataset, AutoTrainVLMDataset
from autotrain.help import get_app_help
from autotrain.project import AutoTrainProject
logger.info('Starting AutoTrain...')
HF_TOKEN = os.environ.get('HF_TOKEN', None)
IS_RUNNING_IN_SPACE = 'SPACE_ID' in os.environ
ENABLE_NGC = int(os.environ.get('ENABLE_NGC', 0))
ENABLE_NVCF = int(os.environ.get('ENABLE_NVCF', 0))
AUTOTRAIN_LOCAL = int(os.environ.get('AUTOTRAIN_LOCAL', 1))
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DB = AutoTrainDB('autotrain.db')
MODEL_CHOICE = fetch_models()
ui_router = APIRouter()
templates_path = os.path.join(BASE_DIR, 'templates')
templates = Jinja2Templates(directory=templates_path)
UI_PARAMS = {'mixed_precision': {'type': 'dropdown', 'label': 'Mixed precision', 'options': ['fp16', 'bf16', 'none']}, 'optimizer': {'type': 'dropdown', 'label': 'Optimizer', 'options': ['adamw_torch', 'adamw', 'adam', 'sgd']}, 'scheduler': {'type': 'dropdown', 'label': 'Scheduler', 'options': ['linear', 'cosine', 'cosine_warmup', 'constant']}, 'eval_strategy': {'type': 'dropdown', 'label': 'Evaluation strategy', 'options': ['epoch', 'steps']}, 'logging_steps': {'type': 'number', 'label': 'Logging steps'}, 'save_total_limit': {'type': 'number', 'label': 'Save total limit'}, 'auto_find_batch_size': {'type': 'dropdown', 'label': 'Auto find batch size', 'options': [True, False]}, 'warmup_ratio': {'type': 'number', 'label': 'Warmup proportion'}, 'max_grad_norm': {'type': 'number', 'label': 'Max grad norm'}, 'weight_decay': {'type': 'number', 'label': 'Weight decay'}, 'epochs': {'type': 'number', 'label': 'Epochs'}, 'batch_size': {'type': 'number', 'label': 'Batch size'}, 'lr': {'type': 'number', 'label': 'Learning rate'}, 'seed': {'type': 'number', 'label': 'Seed'}, 'gradient_accumulation': {'type': 'number', 'label': 'Gradient accumulation'}, 'block_size': {'type': 'number', 'label': 'Block size'}, 'model_max_length': {'type': 'number', 'label': 'Model max length'}, 'add_eos_token': {'type': 'dropdown', 'label': 'Add EOS token', 'options': [True, False]}, 'disable_gradient_checkpointing': {'type': 'dropdown', 'label': 'Disable GC', 'options': [True, False]}, 'use_flash_attention_2': {'type': 'dropdown', 'label': 'Use flash attention', 'options': [True, False]}, 'log': {'type': 'dropdown', 'label': 'Logging', 'options': ['tensorboard', 'none']}, 'quantization': {'type': 'dropdown', 'label': 'Quantization', 'options': ['int4', 'int8', 'none']}, 'target_modules': {'type': 'string', 'label': 'Target modules'}, 'merge_adapter': {'type': 'dropdown', 'label': 'Merge adapter', 'options': [True, False]}, 'peft': {'type': 'dropdown', 'label': 'PEFT/LoRA', 'options': [True, False]}, 'lora_r': {'type': 'number', 'label': 'Lora r'}, 'lora_alpha': {'type': 'number', 'label': 'Lora alpha'}, 'lora_dropout': {'type': 'number', 'label': 'Lora dropout'}, 'model_ref': {'type': 'string', 'label': 'Reference model'}, 'dpo_beta': {'type': 'number', 'label': 'DPO beta'}, 'max_prompt_length': {'type': 'number', 'label': 'Prompt length'}, 'max_completion_length': {'type': 'number', 'label': 'Completion length'}, 'chat_template': {'type': 'dropdown', 'label': 'Chat template', 'options': ['none', 'zephyr', 'chatml', 'tokenizer']}, 'padding': {'type': 'dropdown', 'label': 'Padding side', 'options': ['right', 'left', 'none']}, 'max_seq_length': {'type': 'number', 'label': 'Max sequence length'}, 'early_stopping_patience': {'type': 'number', 'label': 'Early stopping patience'}, 'early_stopping_threshold': {'type': 'number', 'label': 'Early stopping threshold'}, 'max_target_length': {'type': 'number', 'label': 'Max target length'}, 'categorical_columns': {'type': 'string', 'label': 'Categorical columns'}, 'numerical_columns': {'type': 'string', 'label': 'Numerical columns'}, 'num_trials': {'type': 'number', 'label': 'Number of trials'}, 'time_limit': {'type': 'number', 'label': 'Time limit'}, 'categorical_imputer': {'type': 'dropdown', 'label': 'Categorical imputer', 'options': ['most_frequent', 'none']}, 'numerical_imputer': {'type': 'dropdown', 'label': 'Numerical imputer', 'options': ['mean', 'median', 'none']}, 'numeric_scaler': {'type': 'dropdown', 'label': 'Numeric scaler', 'options': ['standard', 'minmax', 'maxabs', 'robust', 'none']}, 'vae_model': {'type': 'string', 'label': 'VAE model'}, 'prompt': {'type': 'string', 'label': 'Prompt'}, 'resolution': {'type': 'number', 'label': 'Resolution'}, 'num_steps': {'type': 'number', 'label': 'Number of steps'}, 'checkpointing_steps': {'type': 'number', 'label': 'Checkpointing steps'}, 'use_8bit_adam': {'type': 'dropdown', 'label': 'Use 8-bit Adam', 'options': [True, False]}, 'xformers': {'type': 'dropdown', 'label': 'xFormers', 'options': [True, False]}, 'image_square_size': {'type': 'number', 'label': 'Image square size'}, 'unsloth': {'type': 'dropdown', 'label': 'Unsloth', 'options': [True, False]}, 'max_doc_stride': {'type': 'number', 'label': 'Max doc stride'}}

def graceful_exit(signum, frame):
    logger.info('SIGTERM received. Performing cleanup...')
    sys.exit(0)
signal.signal(signal.SIGTERM, graceful_exit)
logger.info('AutoTrain started successfully')

def user_authentication(request: Request):
    if HF_TOKEN is not None:
        try:
            _ = token_verification(token=os.environ.get('HF_TOKEN'))
            return HF_TOKEN
        except Exception as e:
            logger.error(f'Failed to verify token: {e}')
            if IS_RUNNING_IN_SPACE:
                return templates.TemplateResponse('login.html', {'request': request})
            else:
                raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail='Invalid or expired token: HF_TOKEN')
    if IS_RUNNING_IN_SPACE and 'oauth_info' in request.session:
        try:
            _ = token_verification(token=request.session['oauth_info']['access_token'])
            return request.session['oauth_info']['access_token']
        except Exception as e:
            request.session.pop('oauth_info', None)
            logger.error(f'Failed to verify token: {e}')
            return templates.TemplateResponse('login.html', {'request': request})
    if IS_RUNNING_IN_SPACE:
        return templates.TemplateResponse('login.html', {'request': request})
    raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail='Invalid or expired token')

@ui_router.get('/', response_class=HTMLResponse)
async def load_index(request: Request, token: str=Depends(user_authentication)):
    if os.environ.get('SPACE_ID') == 'autotrain-projects/autotrain-advanced':
        return templates.TemplateResponse('duplicate.html', {'request': request})
    try:
        _users = get_user_and_orgs(user_token=token)
    except Exception as e:
        logger.error(f'Failed to get user and orgs: {e}')
        if 'oauth_info' in request.session:
            request.session.pop('oauth_info', None)
        return templates.TemplateResponse('login.html', {'request': request})
    context = {'request': request, 'valid_users': _users, 'enable_ngc': ENABLE_NGC, 'enable_nvcf': ENABLE_NVCF, 'enable_local': AUTOTRAIN_LOCAL, 'version': __version__, 'time': time.strftime('%Y-%m-%d %H:%M:%S')}
    return templates.TemplateResponse('index.html', context)

@ui_router.get('/logout', response_class=HTMLResponse)
async def oauth_logout(request: Request, authenticated: bool=Depends(user_authentication)):
    request.session.pop('oauth_info', None)
    return RedirectResponse('/')

@ui_router.get('/params/{task}/{param_type}', response_class=JSONResponse)
async def fetch_params(task: str, param_type: str, authenticated: bool=Depends(user_authentication)):
    logger.info(f'Task: {task}')
    task_params = get_task_params(task, param_type)
    if len(task_params) == 0:
        return {'error': 'Task not found'}
    ui_params = {}
    for param in task_params:
        if param in UI_PARAMS:
            ui_params[param] = UI_PARAMS[param]
            ui_params[param]['default'] = task_params[param]
        else:
            logger.info(f'Param {param} not found in UI_PARAMS')
    ui_params = dict(sorted(ui_params.items(), key=lambda x: (x[1]['type'], x[1]['label'])))
    return ui_params

@ui_router.get('/model_choices/{task}', response_class=JSONResponse)
async def fetch_model_choices(task: str, custom_models: str=Query(None), authenticated: bool=Depends(user_authentication)):
    resp = []
    if custom_models is not None:
        custom_models = custom_models.split(',')
        for custom_model in custom_models:
            custom_model = custom_model.strip()
            resp.append({'id': custom_model, 'name': custom_model})
    if os.environ.get('AUTOTRAIN_CUSTOM_MODELS', None) is not None:
        custom_models = os.environ.get('AUTOTRAIN_CUSTOM_MODELS')
        custom_models = custom_models.split(',')
        for custom_model in custom_models:
            custom_model = custom_model.strip()
            resp.append({'id': custom_model, 'name': custom_model})
    if task == 'text-classification':
        hub_models = MODEL_CHOICE['text-classification']
    elif task.startswith('llm'):
        hub_models = MODEL_CHOICE['llm']
    elif task.startswith('st:'):
        hub_models = MODEL_CHOICE['sentence-transformers']
    elif task == 'image-classification':
        hub_models = MODEL_CHOICE['image-classification']
    elif task == 'dreambooth':
        hub_models = MODEL_CHOICE['dreambooth']
    elif task == 'seq2seq':
        hub_models = MODEL_CHOICE['seq2seq']
    elif task == 'tabular:classification':
        hub_models = MODEL_CHOICE['tabular-classification']
    elif task == 'tabular:regression':
        hub_models = MODEL_CHOICE['tabular-regression']
    elif task == 'token-classification':
        hub_models = MODEL_CHOICE['token-classification']
    elif task == 'text-regression':
        hub_models = MODEL_CHOICE['text-regression']
    elif task == 'image-object-detection':
        hub_models = MODEL_CHOICE['image-object-detection']
    elif task == 'image-regression':
        hub_models = MODEL_CHOICE['image-regression']
    elif task.startswith('vlm:'):
        hub_models = MODEL_CHOICE['vlm']
    elif task == 'extractive-qa':
        hub_models = MODEL_CHOICE['extractive-qa']
    else:
        raise NotImplementedError
    for hub_model in hub_models:
        resp.append({'id': hub_model, 'name': hub_model})
    return resp

@ui_router.post('/create_project', response_class=JSONResponse)
async def handle_form(project_name: str=Form(...), task: str=Form(...), base_model: str=Form(...), hardware: str=Form(...), params: str=Form(...), autotrain_user: str=Form(...), column_mapping: str=Form('{"default": "value"}'), data_files_training: List[UploadFile]=File(None), data_files_valid: List[UploadFile]=File(None), hub_dataset: str=Form(''), train_split: str=Form(''), valid_split: str=Form(''), token: str=Depends(user_authentication)):
    train_split = train_split.strip()
    if len(train_split) == 0:
        train_split = None
    valid_split = valid_split.strip()
    if len(valid_split) == 0:
        valid_split = None
    logger.info(f'hardware: {hardware}')
    if hardware == 'local-ui':
        running_jobs = get_running_jobs(DB)
        if running_jobs:
            raise HTTPException(status_code=409, detail='Another job is already running. Please wait for it to finish.')
    if repo_exists(f'{autotrain_user}/{project_name}', token=token):
        raise HTTPException(status_code=409, detail=f'Project {project_name} already exists. Please choose a different name.')
    params = json.loads(params)
    for key in params:
        if params[key] == 'null':
            params[key] = None
    column_mapping = json.loads(column_mapping)
    training_files = [f.file for f in data_files_training if f.filename != ''] if data_files_training else []
    validation_files = [f.file for f in data_files_valid if f.filename != ''] if data_files_valid else []
    if len(training_files) > 0 and len(hub_dataset) > 0:
        raise HTTPException(status_code=400, detail='Please either upload a dataset or choose a dataset from the Hugging Face Hub.')
    if len(training_files) == 0 and len(hub_dataset) == 0:
        raise HTTPException(status_code=400, detail='Please upload a dataset or choose a dataset from the Hugging Face Hub.')
    if len(hub_dataset) > 0 and task == 'dreambooth':
        raise HTTPException(status_code=400, detail='Dreambooth does not support Hugging Face Hub datasets.')
    if len(hub_dataset) > 0:
        if not train_split:
            raise HTTPException(status_code=400, detail='Please enter a training split.')
    if len(hub_dataset) == 0:
        file_extension = os.path.splitext(data_files_training[0].filename)[1]
        file_extension = file_extension[1:] if file_extension.startswith('.') else file_extension
        if task == 'image-classification':
            dset = AutoTrainImageClassificationDataset(train_data=training_files[0], token=token, project_name=project_name, username=autotrain_user, valid_data=validation_files[0] if validation_files else None, percent_valid=None, local=hardware.lower() == 'local-ui')
        elif task == 'image-regression':
            dset = AutoTrainImageRegressionDataset(train_data=training_files[0], token=token, project_name=project_name, username=autotrain_user, valid_data=validation_files[0] if validation_files else None, percent_valid=None, local=hardware.lower() == 'local-ui')
        elif task == 'image-object-detection':
            dset = AutoTrainObjectDetectionDataset(train_data=training_files[0], token=token, project_name=project_name, username=autotrain_user, valid_data=validation_files[0] if validation_files else None, percent_valid=None, local=hardware.lower() == 'local-ui')
        elif task == 'dreambooth':
            dset = AutoTrainDreamboothDataset(concept_images=data_files_training, concept_name=params['prompt'], token=token, project_name=project_name, username=autotrain_user, local=hardware.lower() == 'local-ui')
        elif task.startswith('vlm:'):
            dset = AutoTrainVLMDataset(train_data=training_files[0], token=token, project_name=project_name, username=autotrain_user, column_mapping=column_mapping, valid_data=validation_files[0] if validation_files else None, percent_valid=None, local=hardware.lower() == 'local-ui')
        else:
            if task.startswith('llm'):
                dset_task = 'lm_training'
            elif task.startswith('st:'):
                dset_task = 'sentence_transformers'
            elif task == 'text-classification':
                dset_task = 'text_multi_class_classification'
            elif task == 'text-regression':
                dset_task = 'text_single_column_regression'
            elif task == 'seq2seq':
                dset_task = 'seq2seq'
            elif task.startswith('tabular'):
                if ',' in column_mapping['label']:
                    column_mapping['label'] = column_mapping['label'].split(',')
                else:
                    column_mapping['label'] = [column_mapping['label']]
                column_mapping['label'] = [col.strip() for col in column_mapping['label']]
                subtask = task.split(':')[-1].lower()
                if len(column_mapping['label']) > 1 and subtask == 'classification':
                    dset_task = 'tabular_multi_label_classification'
                elif len(column_mapping['label']) == 1 and subtask == 'classification':
                    dset_task = 'tabular_multi_class_classification'
                elif len(column_mapping['label']) > 1 and subtask == 'regression':
                    dset_task = 'tabular_multi_column_regression'
                elif len(column_mapping['label']) == 1 and subtask == 'regression':
                    dset_task = 'tabular_single_column_regression'
                else:
                    raise NotImplementedError
            elif task == 'token-classification':
                dset_task = 'text_token_classification'
            elif task == 'extractive-qa':
                dset_task = 'text_extractive_question_answering'
            else:
                raise NotImplementedError
            logger.info(f'Task: {dset_task}')
            logger.info(f'Column mapping: {column_mapping}')
            dset_args = dict(train_data=training_files, task=dset_task, token=token, project_name=project_name, username=autotrain_user, column_mapping=column_mapping, valid_data=validation_files, percent_valid=None, local=hardware.lower() == 'local-ui', ext=file_extension)
            if task in ('text-classification', 'token-classification', 'st:pair_class'):
                dset_args['convert_to_class_label'] = True
            dset = AutoTrainDataset(**dset_args)
        data_path = dset.prepare()
    else:
        data_path = hub_dataset
    app_params = AppParams(job_params_json=json.dumps(params), token=token, project_name=project_name, username=autotrain_user, task=task, data_path=data_path, base_model=base_model, column_mapping=column_mapping, using_hub_dataset=len(hub_dataset) > 0, train_split=None if len(hub_dataset) == 0 else train_split, valid_split=None if len(hub_dataset) == 0 else valid_split)
    params = app_params.munge()
    project = AutoTrainProject(params=params, backend=hardware)
    job_id = project.create()
    monitor_url = ''
    if hardware == 'local-ui':
        DB.add_job(job_id)
        monitor_url = 'Monitor your job locally / in logs'
    elif hardware.startswith('ep-'):
        monitor_url = f'https://ui.endpoints.huggingface.co/{autotrain_user}/endpoints/{job_id}'
    elif hardware.startswith('spaces-'):
        monitor_url = f'https://hf.co/spaces/{job_id}'
    else:
        monitor_url = f'Success! Monitor your job in logs. Job ID: {job_id}'
    return {'success': 'true', 'monitor_url': monitor_url}

@ui_router.get('/help/{element_id}', response_class=JSONResponse)
async def fetch_help(element_id: str, authenticated: bool=Depends(user_authentication)):
    msg = get_app_help(element_id)
    return {'message': msg}

@ui_router.get('/accelerators', response_class=JSONResponse)
async def available_accelerators(authenticated: bool=Depends(user_authentication)):
    if AUTOTRAIN_LOCAL == 0:
        return {'accelerators': 'Not available in cloud mode.'}
    cuda_available = torch.cuda.is_available()
    mps_available = torch.backends.mps.is_available()
    if cuda_available:
        num_gpus = torch.cuda.device_count()
    elif mps_available:
        num_gpus = 1
    else:
        num_gpus = 0
    return {'accelerators': num_gpus}

@ui_router.get('/is_model_training', response_class=JSONResponse)
async def is_model_training(authenticated: bool=Depends(user_authentication)):
    if AUTOTRAIN_LOCAL == 0:
        return {'model_training': 'Not available in cloud mode.'}
    running_jobs = get_running_jobs(DB)
    if running_jobs:
        return {'model_training': True, 'pids': running_jobs}
    return {'model_training': False, 'pids': []}

@ui_router.get('/logs', response_class=JSONResponse)
async def fetch_logs(authenticated: bool=Depends(user_authentication)):
    if not AUTOTRAIN_LOCAL:
        return {'logs': 'Logs are only available in local mode.'}
    log_file = 'autotrain.log'
    with open(log_file, 'r', encoding='utf-8') as f:
        logs = f.read()
    if len(str(logs).strip()) == 0:
        logs = 'No logs available.'
    logs = logs.split('\n')
    logs = logs[::-1]
    logs = [log for log in logs if '/ui/' not in log and '/static/' not in log and ('nvidia-ml-py' not in log)]
    cuda_available = torch.cuda.is_available()
    if cuda_available:
        devices = Device.all()
        device_logs = []
        for device in devices:
            device_logs.append(f'Device {device.index}: {device.name()} - {device.memory_used_human()}/{device.memory_total_human()}')
        device_logs.append('-----------------')
        logs = device_logs + logs
    return {'logs': logs}

@ui_router.get('/stop_training', response_class=JSONResponse)
async def stop_training(authenticated: bool=Depends(user_authentication)):
    running_jobs = get_running_jobs(DB)
    if running_jobs:
        for _pid in running_jobs:
            try:
                kill_process_by_pid(_pid)
            except Exception:
                logger.info(f'Process {_pid} is already completed. Skipping...')
        return {'success': True}
    return {'success': False}

# File: autotrain-advanced-main/src/autotrain/app/utils.py
import os
import signal
import sys
import psutil
import requests
from autotrain import config, logger

def graceful_exit(signum, frame):
    logger.info('SIGTERM received. Performing cleanup...')
    sys.exit(0)
signal.signal(signal.SIGTERM, graceful_exit)

def get_running_jobs(db):
    running_jobs = db.get_running_jobs()
    if running_jobs:
        for _pid in running_jobs:
            proc_status = get_process_status(_pid)
            proc_status = proc_status.strip().lower()
            if proc_status in ('completed', 'error', 'zombie'):
                logger.info(f'Killing PID: {_pid}')
                try:
                    kill_process_by_pid(_pid)
                except Exception as e:
                    logger.info(f'Error while killing process: {e}')
                    logger.info(f'Process {_pid} is already completed. Skipping...')
                db.delete_job(_pid)
    running_jobs = db.get_running_jobs()
    return running_jobs

def get_process_status(pid):
    try:
        process = psutil.Process(pid)
        proc_status = process.status()
        return proc_status
    except psutil.NoSuchProcess:
        logger.info(f'No process found with PID: {pid}')
        return 'Completed'

def kill_process_by_pid(pid):
    try:
        os.kill(pid, signal.SIGTERM)
        logger.info(f'Sent SIGTERM to process with PID {pid}')
    except ProcessLookupError:
        logger.error(f'No process found with PID {pid}')
    except Exception as e:
        logger.error(f'Failed to send SIGTERM to process with PID {pid}: {e}')

def token_verification(token):
    if token.startswith('hf_oauth'):
        _api_url = config.HF_API + '/oauth/userinfo'
        _err_msg = '/oauth/userinfo'
    else:
        _api_url = config.HF_API + '/api/whoami-v2'
        _err_msg = '/api/whoami-v2'
    headers = {}
    cookies = {}
    if token.startswith('hf_'):
        headers['Authorization'] = f'Bearer {token}'
    else:
        cookies = {'token': token}
    try:
        response = requests.get(_api_url, headers=headers, cookies=cookies, timeout=3)
    except (requests.Timeout, ConnectionError) as err:
        logger.error(f'Failed to request {_err_msg} - {repr(err)}')
        raise Exception(f'Hugging Face Hub ({_err_msg}) is unreachable, please try again later.')
    if response.status_code != 200:
        logger.error(f'Failed to request {_err_msg} - {response.status_code}')
        raise Exception(f'Invalid token ({_err_msg}). Please login with a write token.')
    resp = response.json()
    user_info = {}
    if token.startswith('hf_oauth'):
        user_info['id'] = resp['sub']
        user_info['name'] = resp['preferred_username']
        user_info['orgs'] = [resp['orgs'][k]['preferred_username'] for k in range(len(resp['orgs']))]
    else:
        user_info['id'] = resp['id']
        user_info['name'] = resp['name']
        user_info['orgs'] = [resp['orgs'][k]['name'] for k in range(len(resp['orgs']))]
    return user_info

def get_user_and_orgs(user_token):
    if user_token is None:
        raise Exception('Please login with a write token.')
    if user_token is None or len(user_token) == 0:
        raise Exception('Invalid token. Please login with a write token.')
    user_info = token_verification(token=user_token)
    username = user_info['name']
    orgs = user_info['orgs']
    who_is_training = [username] + orgs
    return who_is_training

# File: autotrain-advanced-main/src/autotrain/backends/base.py
import json
from dataclasses import dataclass
from typing import Union
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams
from autotrain.trainers.extractive_question_answering.params import ExtractiveQuestionAnsweringParams
from autotrain.trainers.generic.params import GenericParams
from autotrain.trainers.image_classification.params import ImageClassificationParams
from autotrain.trainers.image_regression.params import ImageRegressionParams
from autotrain.trainers.object_detection.params import ObjectDetectionParams
from autotrain.trainers.sent_transformers.params import SentenceTransformersParams
from autotrain.trainers.seq2seq.params import Seq2SeqParams
from autotrain.trainers.tabular.params import TabularParams
from autotrain.trainers.text_classification.params import TextClassificationParams
from autotrain.trainers.text_regression.params import TextRegressionParams
from autotrain.trainers.token_classification.params import TokenClassificationParams
from autotrain.trainers.vlm.params import VLMTrainingParams
AVAILABLE_HARDWARE = {'spaces-a10g-large': 'a10g-large', 'spaces-a10g-small': 'a10g-small', 'spaces-a100-large': 'a100-large', 'spaces-t4-medium': 't4-medium', 'spaces-t4-small': 't4-small', 'spaces-cpu-upgrade': 'cpu-upgrade', 'spaces-cpu-basic': 'cpu-basic', 'spaces-l4x1': 'l4x1', 'spaces-l4x4': 'l4x4', 'spaces-l40sx1': 'l40sx1', 'spaces-l40sx4': 'l40sx4', 'spaces-l40sx8': 'l40sx8', 'spaces-a10g-largex2': 'a10g-largex2', 'spaces-a10g-largex4': 'a10g-largex4', 'dgx-a100': 'dgxa100.80g.1.norm', 'dgx-2a100': 'dgxa100.80g.2.norm', 'dgx-4a100': 'dgxa100.80g.4.norm', 'dgx-8a100': 'dgxa100.80g.8.norm', 'ep-aws-useast1-s': 'aws_us-east-1_gpu_small_g4dn.xlarge', 'ep-aws-useast1-m': 'aws_us-east-1_gpu_medium_g5.2xlarge', 'ep-aws-useast1-l': 'aws_us-east-1_gpu_large_g4dn.12xlarge', 'ep-aws-useast1-xl': 'aws_us-east-1_gpu_xlarge_p4de', 'ep-aws-useast1-2xl': 'aws_us-east-1_gpu_2xlarge_p4de', 'ep-aws-useast1-4xl': 'aws_us-east-1_gpu_4xlarge_p4de', 'ep-aws-useast1-8xl': 'aws_us-east-1_gpu_8xlarge_p4de', 'nvcf-l40sx1': {'id': '67bb8939-c932-429a-a446-8ae898311856'}, 'nvcf-h100x1': {'id': '848348f8-a4e2-4242-bce9-6baa1bd70a66'}, 'nvcf-h100x2': {'id': 'fb006a89-451e-4d9c-82b5-33eff257e0bf'}, 'nvcf-h100x4': {'id': '21bae5af-87e5-4132-8fc0-bf3084e59a57'}, 'nvcf-h100x8': {'id': '6e0c2af6-5368-47e0-b15e-c070c2c92018'}, 'local-ui': 'local', 'local': 'local', 'local-cli': 'local'}

@dataclass
class BaseBackend:
    params: Union[TextClassificationParams, ImageClassificationParams, LLMTrainingParams, GenericParams, TabularParams, DreamBoothTrainingParams, Seq2SeqParams, TokenClassificationParams, TextRegressionParams, ObjectDetectionParams, SentenceTransformersParams, ImageRegressionParams, VLMTrainingParams, ExtractiveQuestionAnsweringParams]
    backend: str

    def __post_init__(self):
        self.username = None
        if isinstance(self.params, GenericParams) and self.backend.startswith('local'):
            raise ValueError('Local backend is not supported for GenericParams')
        if self.backend.startswith('spaces-') or self.backend.startswith('ep-') or self.backend.startswith('ngc-') or self.backend.startswith('nvcf-'):
            if self.params.username is not None:
                self.username = self.params.username
            else:
                raise ValueError('Must provide username')
        if isinstance(self.params, LLMTrainingParams):
            self.task_id = 9
        elif isinstance(self.params, TextClassificationParams):
            self.task_id = 2
        elif isinstance(self.params, TabularParams):
            self.task_id = 26
        elif isinstance(self.params, GenericParams):
            self.task_id = 27
        elif isinstance(self.params, DreamBoothTrainingParams):
            self.task_id = 25
        elif isinstance(self.params, Seq2SeqParams):
            self.task_id = 28
        elif isinstance(self.params, ImageClassificationParams):
            self.task_id = 18
        elif isinstance(self.params, TokenClassificationParams):
            self.task_id = 4
        elif isinstance(self.params, TextRegressionParams):
            self.task_id = 10
        elif isinstance(self.params, ObjectDetectionParams):
            self.task_id = 29
        elif isinstance(self.params, SentenceTransformersParams):
            self.task_id = 30
        elif isinstance(self.params, ImageRegressionParams):
            self.task_id = 24
        elif isinstance(self.params, VLMTrainingParams):
            self.task_id = 31
        elif isinstance(self.params, ExtractiveQuestionAnsweringParams):
            self.task_id = 5
        else:
            raise NotImplementedError
        self.available_hardware = AVAILABLE_HARDWARE
        self.wait = False
        if self.backend == 'local-ui':
            self.wait = False
        if self.backend in ('local', 'local-cli'):
            self.wait = True
        self.env_vars = {'HF_TOKEN': self.params.token, 'AUTOTRAIN_USERNAME': self.username, 'PROJECT_NAME': self.params.project_name, 'TASK_ID': str(self.task_id), 'PARAMS': json.dumps(self.params.model_dump_json())}
        if isinstance(self.params, DreamBoothTrainingParams):
            self.env_vars['DATA_PATH'] = self.params.image_path
        else:
            self.env_vars['DATA_PATH'] = self.params.data_path
        if not isinstance(self.params, GenericParams):
            self.env_vars['MODEL'] = self.params.model

# File: autotrain-advanced-main/src/autotrain/backends/endpoints.py
import requests
from autotrain.backends.base import BaseBackend
ENDPOINTS_URL = 'https://api.endpoints.huggingface.cloud/v2/endpoint/'

class EndpointsRunner(BaseBackend):

    def create(self):
        hardware = self.available_hardware[self.backend]
        accelerator = hardware.split('_')[2]
        instance_size = hardware.split('_')[3]
        region = hardware.split('_')[1]
        vendor = hardware.split('_')[0]
        instance_type = hardware.split('_')[4]
        payload = {'accountId': self.username, 'compute': {'accelerator': accelerator, 'instanceSize': instance_size, 'instanceType': instance_type, 'scaling': {'maxReplica': 1, 'minReplica': 1}}, 'model': {'framework': 'custom', 'image': {'custom': {'env': {'HF_TOKEN': self.params.token, 'AUTOTRAIN_USERNAME': self.username, 'PROJECT_NAME': self.params.project_name, 'PARAMS': self.params.model_dump_json(), 'DATA_PATH': self.params.data_path, 'TASK_ID': str(self.task_id), 'MODEL': self.params.model, 'ENDPOINT_ID': f'{self.username}/{self.params.project_name}'}, 'health_route': '/', 'port': 7860, 'url': 'public.ecr.aws/z4c3o6n6/autotrain-api:latest'}}, 'repository': 'autotrain-projects/autotrain-advanced', 'revision': 'main', 'task': 'custom'}, 'name': self.params.project_name, 'provider': {'region': region, 'vendor': vendor}, 'type': 'protected'}
        headers = {'Authorization': f'Bearer {self.params.token}'}
        r = requests.post(ENDPOINTS_URL + self.username, json=payload, headers=headers, timeout=120)
        return r.json()['name']

# File: autotrain-advanced-main/src/autotrain/backends/local.py
from autotrain import logger
from autotrain.backends.base import BaseBackend
from autotrain.utils import run_training

class LocalRunner(BaseBackend):

    def create(self):
        logger.info('Starting local training...')
        params = self.env_vars['PARAMS']
        task_id = int(self.env_vars['TASK_ID'])
        training_pid = run_training(params, task_id, local=True, wait=self.wait)
        if not self.wait:
            logger.info(f'Training PID: {training_pid}')
        return training_pid

# File: autotrain-advanced-main/src/autotrain/backends/ngc.py
import base64
import json
import os
import requests
from requests.exceptions import HTTPError
from autotrain import logger
from autotrain.backends.base import BaseBackend
NGC_API = os.environ.get('NGC_API', 'https://api.ngc.nvidia.com/v2/org')
NGC_AUTH = os.environ.get('NGC_AUTH', 'https://authn.nvidia.com')
NGC_ACE = os.environ.get('NGC_ACE')
NGC_ORG = os.environ.get('NGC_ORG')
NGC_API_KEY = os.environ.get('NGC_CLI_API_KEY')
NGC_TEAM = os.environ.get('NGC_TEAM')

class NGCRunner(BaseBackend):

    def _user_authentication_ngc(self):
        logger.info('Authenticating NGC user...')
        scope = 'group/ngc'
        querystring = {'service': 'ngc', 'scope': scope}
        auth = f'$oauthtoken:{NGC_API_KEY}'
        headers = {'Authorization': f"Basic {base64.b64encode(auth.encode('utf-8')).decode('utf-8')}", 'Content-Type': 'application/json', 'Cache-Control': 'no-cache'}
        try:
            response = requests.get(NGC_AUTH + '/token', headers=headers, params=querystring, timeout=30)
        except HTTPError as http_err:
            logger.error(f'HTTP error occurred: {http_err}')
            raise Exception("HTTP Error %d: from '%s'" % (response.status_code, NGC_AUTH))
        except (requests.Timeout, ConnectionError) as err:
            logger.error(f'Failed to request NGC token - {repr(err)}')
            raise Exception('%s is unreachable, please try again later.' % NGC_AUTH)
        return json.loads(response.text.encode('utf8'))['token']

    def _create_ngc_job(self, token, url, payload):
        logger.info('Creating NGC Job')
        headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {token}'}
        try:
            response = requests.post(NGC_API + url + '/jobs', headers=headers, json=payload, timeout=30)
            result = response.json()
            logger.info(f"NGC Job ID: {result.get('job', {}).get('id')}, Job Status History: {result.get('jobStatusHistory')}")
            return result.get('job', {}).get('id')
        except HTTPError as http_err:
            logger.error(f'HTTP error occurred: {http_err}')
            raise Exception(f'HTTP Error {response.status_code}: {http_err}')
        except (requests.Timeout, ConnectionError) as err:
            logger.error(f'Failed to create NGC job - {repr(err)}')
            raise Exception(f'Unreachable, please try again later: {err}')

    def create(self):
        job_name = f'{self.username}-{self.params.project_name}'
        ngc_url = f'/{NGC_ORG}/team/{NGC_TEAM}'
        ngc_cmd = 'set -x; conda run --no-capture-output -p /app/env autotrain api --port 7860 --host 0.0.0.0'
        ngc_payload = {'name': job_name, 'aceName': NGC_ACE, 'aceInstance': self.available_hardware[self.backend], 'dockerImageName': f'{NGC_ORG}/autotrain-advanced:latest', 'command': ngc_cmd, 'envs': [{'name': key, 'value': value} for (key, value) in self.env_vars.items()], 'jobOrder': 50, 'jobPriority': 'NORMAL', 'portMappings': [{'containerPort': 7860, 'protocol': 'HTTPS'}], 'resultContainerMountPoint': '/results', 'runPolicy': {'preemptClass': 'RUNONCE', 'totalRuntimeSeconds': 259200}}
        ngc_token = self._user_authentication_ngc()
        job_id = self._create_ngc_job(ngc_token, ngc_url, ngc_payload)
        return job_id

# File: autotrain-advanced-main/src/autotrain/backends/nvcf.py
import os
import threading
import time
from types import SimpleNamespace
import requests
from autotrain import logger
from autotrain.backends.base import BaseBackend
NVCF_API = 'https://huggingface.co/api/integrations/dgx/v1'

class NVCFRunner(BaseBackend):

    def _convert_dict_to_object(self, dictionary):
        if isinstance(dictionary, dict):
            for (key, value) in dictionary.items():
                dictionary[key] = self._convert_dict_to_object(value)
            return SimpleNamespace(**dictionary)
        elif isinstance(dictionary, list):
            return [self._convert_dict_to_object(item) for item in dictionary]
        else:
            return dictionary

    def _conf_nvcf(self, token, nvcf_type, url, job_name, method='POST', payload=None):
        logger.info(f'{job_name}: {method} - Configuring NVCF {nvcf_type}.')
        headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {token}'}
        try:
            if method.upper() == 'POST':
                response = requests.post(url, headers=headers, json=payload, timeout=30)
            else:
                raise ValueError(f'Unsupported HTTP method: {method}')
            response.raise_for_status()
            if response.status_code == 202:
                logger.info(f'{job_name}: {method} - Successfully submitted NVCF job. Polling reqId for completion')
                response_data = response.json()
                nvcf_reqid = response_data.get('nvcfRequestId')
                if nvcf_reqid:
                    logger.info(f'{job_name}: nvcfRequestId: {nvcf_reqid}')
                    return nvcf_reqid
                logger.warning(f'{job_name}: nvcfRequestId key is missing in the response body')
                return None
            result = response.json()
            result_obj = self._convert_dict_to_object(result)
            logger.info(f'{job_name}: {method} - Successfully processed NVCF {nvcf_type}.')
            return result_obj
        except requests.HTTPError as http_err:
            error_message = http_err.response.text if http_err.response else 'No additional error information.'
            logger.error(f'{job_name}: HTTP error occurred processing NVCF {nvcf_type} with {method} request: {http_err}. Error details: {error_message}')
            raise Exception(f'HTTP Error {http_err.response.status_code}: {http_err}. Details: {error_message}')
        except (requests.Timeout, ConnectionError) as err:
            logger.error(f'{job_name}: Failed to process NVCF {nvcf_type} with {method} request - {repr(err)}')
            raise Exception(f'Unreachable, please try again later: {err}')

    def _poll_nvcf(self, url, token, job_name, method='get', timeout=86400, interval=30, op='poll'):
        timeout = float(timeout)
        interval = float(interval)
        start_time = time.time()
        success = False
        last_full_log = ''
        while time.time() - start_time < timeout:
            try:
                headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {token}'}
                if method.upper() == 'GET':
                    response = requests.get(url, headers=headers)
                else:
                    raise ValueError(f'Unsupported HTTP method: {method}')
                if response.status_code == 404 and success:
                    break
                response.raise_for_status()
                try:
                    data = response.json()
                except ValueError:
                    logger.error('Failed to parse JSON from response')
                    continue
                if response.status_code == 500:
                    logger.error('Training failed')
                    if 'detail' in data:
                        detail_message = data['detail']
                        for line in detail_message.split('\n'):
                            if line.strip():
                                print(line)
                    break
                if response.status_code in [200, 202]:
                    logger.info(f"{job_name}: {method} - {response.status_code} - {('Polling completed' if response.status_code == 200 else 'Polling reqId for completion')}")
                    if 'log' in data:
                        current_full_log = data['log']
                        if current_full_log != last_full_log:
                            new_log_content = current_full_log[len(last_full_log):]
                            for line in new_log_content.split('\n'):
                                if line.strip():
                                    print(line)
                            last_full_log = current_full_log
                    if response.status_code == 200:
                        success = True
            except requests.HTTPError as http_err:
                if not (http_err.response.status_code == 404 and success):
                    logger.error(f'HTTP error occurred: {http_err}')
            except (requests.ConnectionError, ValueError) as err:
                logger.error(f'Error while handling request: {err}')
            time.sleep(interval)
        if not success:
            raise TimeoutError(f"Operation '{op}' did not complete successfully within the timeout period.")

    def create(self):
        hf_token = self.env_vars['HF_TOKEN']
        job_name = f'{self.username}-{self.params.project_name}'
        logger.info('Starting NVCF training')
        logger.info(f'job_name: {job_name}')
        logger.info(f'backend: {self.backend}')
        nvcf_url_submit = f"{NVCF_API}/invoke/{self.available_hardware[self.backend]['id']}"
        org_name = os.environ.get('SPACE_ID')
        if org_name is None:
            raise ValueError('SPACE_ID environment variable is not set')
        org_name = org_name.split('/')[0]
        nvcf_fr_payload = {'cmd': ['conda', 'run', '--no-capture-output', '-p', '/app/env', 'python', '-u', '-m', 'uvicorn', 'autotrain.app.training_api:api', '--host', '0.0.0.0', '--port', '7860'], 'env': {key: value for (key, value) in self.env_vars.items()}, 'ORG_NAME': org_name}
        nvcf_fn_req = self._conf_nvcf(token=hf_token, nvcf_type='job_submit', url=nvcf_url_submit, job_name=job_name, method='POST', payload=nvcf_fr_payload)
        nvcf_url_reqpoll = f'{NVCF_API}/status/{nvcf_fn_req}'
        logger.info(f'{job_name}: Polling : {nvcf_url_reqpoll}')
        poll_thread = threading.Thread(target=self._poll_nvcf, kwargs={'url': nvcf_url_reqpoll, 'token': hf_token, 'job_name': job_name, 'method': 'GET', 'timeout': 172800, 'interval': 20})
        poll_thread.start()
        return nvcf_fn_req

# File: autotrain-advanced-main/src/autotrain/backends/spaces.py
import io
from huggingface_hub import HfApi
from autotrain.backends.base import BaseBackend
from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams
from autotrain.trainers.generic.params import GenericParams
_DOCKERFILE = '\nFROM huggingface/autotrain-advanced:latest\n\nCMD pip uninstall -y autotrain-advanced && pip install -U autotrain-advanced && autotrain api --port 7860 --host 0.0.0.0\n'
_DOCKERFILE = _DOCKERFILE.replace('\n', ' ').replace('  ', '\n').strip()

class SpaceRunner(BaseBackend):

    def _create_readme(self):
        _readme = '---\n'
        _readme += f'title: {self.params.project_name}\n'
        _readme += 'emoji: 🚀\n'
        _readme += 'colorFrom: green\n'
        _readme += 'colorTo: indigo\n'
        _readme += 'sdk: docker\n'
        _readme += 'pinned: false\n'
        _readme += 'duplicated_from: autotrain-projects/autotrain-advanced\n'
        _readme += '---\n'
        _readme = io.BytesIO(_readme.encode())
        return _readme

    def _add_secrets(self, api, space_id):
        if isinstance(self.params, GenericParams):
            for (k, v) in self.params.env.items():
                api.add_space_secret(repo_id=space_id, key=k, value=v)
            self.params.env = {}
        api.add_space_secret(repo_id=space_id, key='HF_TOKEN', value=self.params.token)
        api.add_space_secret(repo_id=space_id, key='AUTOTRAIN_USERNAME', value=self.username)
        api.add_space_secret(repo_id=space_id, key='PROJECT_NAME', value=self.params.project_name)
        api.add_space_secret(repo_id=space_id, key='TASK_ID', value=str(self.task_id))
        api.add_space_secret(repo_id=space_id, key='PARAMS', value=self.params.model_dump_json())
        if isinstance(self.params, DreamBoothTrainingParams):
            api.add_space_secret(repo_id=space_id, key='DATA_PATH', value=self.params.image_path)
        else:
            api.add_space_secret(repo_id=space_id, key='DATA_PATH', value=self.params.data_path)
        if not isinstance(self.params, GenericParams):
            api.add_space_secret(repo_id=space_id, key='MODEL', value=self.params.model)

    def create(self):
        api = HfApi(token=self.params.token)
        space_id = f'{self.username}/autotrain-{self.params.project_name}'
        api.create_repo(repo_id=space_id, repo_type='space', space_sdk='docker', space_hardware=self.available_hardware[self.backend], private=True)
        self._add_secrets(api, space_id)
        readme = self._create_readme()
        api.upload_file(path_or_fileobj=readme, path_in_repo='README.md', repo_id=space_id, repo_type='space')
        _dockerfile = io.BytesIO(_DOCKERFILE.encode())
        api.upload_file(path_or_fileobj=_dockerfile, path_in_repo='Dockerfile', repo_id=space_id, repo_type='space')
        return space_id

# File: autotrain-advanced-main/src/autotrain/cli/__init__.py
from abc import ABC, abstractmethod
from argparse import ArgumentParser

class BaseAutoTrainCommand(ABC):

    @staticmethod
    @abstractmethod
    def register_subcommand(parser: ArgumentParser):
        raise NotImplementedError()

    @abstractmethod
    def run(self):
        raise NotImplementedError()

# File: autotrain-advanced-main/src/autotrain/cli/autotrain.py
import argparse
from autotrain import __version__, logger
from autotrain.cli.run_api import RunAutoTrainAPICommand
from autotrain.cli.run_app import RunAutoTrainAppCommand
from autotrain.cli.run_dreambooth import RunAutoTrainDreamboothCommand
from autotrain.cli.run_extractive_qa import RunAutoTrainExtractiveQACommand
from autotrain.cli.run_image_classification import RunAutoTrainImageClassificationCommand
from autotrain.cli.run_image_regression import RunAutoTrainImageRegressionCommand
from autotrain.cli.run_llm import RunAutoTrainLLMCommand
from autotrain.cli.run_object_detection import RunAutoTrainObjectDetectionCommand
from autotrain.cli.run_sent_tranformers import RunAutoTrainSentenceTransformersCommand
from autotrain.cli.run_seq2seq import RunAutoTrainSeq2SeqCommand
from autotrain.cli.run_setup import RunSetupCommand
from autotrain.cli.run_spacerunner import RunAutoTrainSpaceRunnerCommand
from autotrain.cli.run_tabular import RunAutoTrainTabularCommand
from autotrain.cli.run_text_classification import RunAutoTrainTextClassificationCommand
from autotrain.cli.run_text_regression import RunAutoTrainTextRegressionCommand
from autotrain.cli.run_token_classification import RunAutoTrainTokenClassificationCommand
from autotrain.cli.run_tools import RunAutoTrainToolsCommand
from autotrain.parser import AutoTrainConfigParser

def main():
    parser = argparse.ArgumentParser('AutoTrain advanced CLI', usage='autotrain <command> [<args>]', epilog='For more information about a command, run: `autotrain <command> --help`')
    parser.add_argument('--version', '-v', help='Display AutoTrain version', action='store_true')
    parser.add_argument('--config', help='Optional configuration file', type=str)
    commands_parser = parser.add_subparsers(help='commands')
    RunAutoTrainAppCommand.register_subcommand(commands_parser)
    RunAutoTrainLLMCommand.register_subcommand(commands_parser)
    RunSetupCommand.register_subcommand(commands_parser)
    RunAutoTrainDreamboothCommand.register_subcommand(commands_parser)
    RunAutoTrainAPICommand.register_subcommand(commands_parser)
    RunAutoTrainTextClassificationCommand.register_subcommand(commands_parser)
    RunAutoTrainImageClassificationCommand.register_subcommand(commands_parser)
    RunAutoTrainTabularCommand.register_subcommand(commands_parser)
    RunAutoTrainSpaceRunnerCommand.register_subcommand(commands_parser)
    RunAutoTrainSeq2SeqCommand.register_subcommand(commands_parser)
    RunAutoTrainTokenClassificationCommand.register_subcommand(commands_parser)
    RunAutoTrainToolsCommand.register_subcommand(commands_parser)
    RunAutoTrainTextRegressionCommand.register_subcommand(commands_parser)
    RunAutoTrainObjectDetectionCommand.register_subcommand(commands_parser)
    RunAutoTrainSentenceTransformersCommand.register_subcommand(commands_parser)
    RunAutoTrainImageRegressionCommand.register_subcommand(commands_parser)
    RunAutoTrainExtractiveQACommand.register_subcommand(commands_parser)
    args = parser.parse_args()
    if args.version:
        print(__version__)
        exit(0)
    if args.config:
        logger.info(f'Using AutoTrain configuration: {args.config}')
        cp = AutoTrainConfigParser(args.config)
        cp.run()
        exit(0)
    if not hasattr(args, 'func'):
        parser.print_help()
        exit(1)
    command = args.func(args)
    command.run()
if __name__ == '__main__':
    main()

# File: autotrain-advanced-main/src/autotrain/cli/run_api.py
from argparse import ArgumentParser
from . import BaseAutoTrainCommand

def run_api_command_factory(args):
    return RunAutoTrainAPICommand(args.port, args.host, args.task)

class RunAutoTrainAPICommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        run_api_parser = parser.add_parser('api', description='✨ Run AutoTrain API')
        run_api_parser.add_argument('--port', type=int, default=7860, help='Port to run the api on', required=False)
        run_api_parser.add_argument('--host', type=str, default='127.0.0.1', help='Host to run the api on', required=False)
        run_api_parser.add_argument('--task', type=str, required=False, help='Task to run')
        run_api_parser.set_defaults(func=run_api_command_factory)

    def __init__(self, port, host, task):
        self.port = port
        self.host = host
        self.task = task

    def run(self):
        import uvicorn
        from autotrain.app.training_api import api
        uvicorn.run(api, host=self.host, port=self.port)

# File: autotrain-advanced-main/src/autotrain/cli/run_app.py
import os
import signal
import subprocess
import sys
import threading
from argparse import ArgumentParser
from autotrain import logger
from . import BaseAutoTrainCommand

def handle_output(stream, log_file):
    while True:
        line = stream.readline()
        if not line:
            break
        sys.stdout.write(line)
        sys.stdout.flush()
        log_file.write(line)
        log_file.flush()

def run_app_command_factory(args):
    return RunAutoTrainAppCommand(args.port, args.host, args.share, args.workers, args.colab)

class RunAutoTrainAppCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        run_app_parser = parser.add_parser('app', description='✨ Run AutoTrain app')
        run_app_parser.add_argument('--port', type=int, default=7860, help='Port to run the app on', required=False)
        run_app_parser.add_argument('--host', type=str, default='127.0.0.1', help='Host to run the app on', required=False)
        run_app_parser.add_argument('--workers', type=int, default=1, help='Number of workers to run the app with', required=False)
        run_app_parser.add_argument('--share', action='store_true', help='Share the app on ngrok', required=False)
        run_app_parser.add_argument('--colab', action='store_true', help='Use app in colab', required=False)
        run_app_parser.set_defaults(func=run_app_command_factory)

    def __init__(self, port, host, share, workers, colab):
        self.port = port
        self.host = host
        self.share = share
        self.workers = workers
        self.colab = colab

    def run(self):
        if self.colab:
            from IPython.display import display
            from autotrain.app.colab import colab_app
            elements = colab_app()
            display(elements)
            return
        if self.share:
            from pyngrok import ngrok
            os.system(f'fuser -n tcp -k {self.port}')
            authtoken = os.environ.get('NGROK_AUTH_TOKEN', '')
            if authtoken.strip() == '':
                logger.info('NGROK_AUTH_TOKEN not set')
                raise ValueError('NGROK_AUTH_TOKEN not set. Please set it!')
            ngrok.set_auth_token(authtoken)
            active_tunnels = ngrok.get_tunnels()
            for tunnel in active_tunnels:
                public_url = tunnel.public_url
                ngrok.disconnect(public_url)
            url = ngrok.connect(addr=self.port, bind_tls=True)
            logger.info(f'AutoTrain Public URL: {url}')
            logger.info('Please wait for the app to load...')
        command = f'uvicorn autotrain.app.app:app --host {self.host} --port {self.port}'
        command += f' --workers {self.workers}'
        with open('autotrain.log', 'w', encoding='utf-8') as log_file:
            if sys.platform == 'win32':
                process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True, text=True, bufsize=1)
            else:
                process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True, text=True, bufsize=1, preexec_fn=os.setsid)
            output_thread = threading.Thread(target=handle_output, args=(process.stdout, log_file))
            output_thread.start()
            try:
                process.wait()
                output_thread.join()
            except KeyboardInterrupt:
                logger.warning('Attempting to terminate the process...')
                if sys.platform == 'win32':
                    process.terminate()
                else:
                    os.killpg(os.getpgid(process.pid), signal.SIGTERM)
                logger.info('Process terminated by user')

# File: autotrain-advanced-main/src/autotrain/cli/run_dreambooth.py
import glob
import os
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli import BaseAutoTrainCommand
from autotrain.cli.utils import common_args, dreambooth_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams
from autotrain.trainers.dreambooth.utils import VALID_IMAGE_EXTENSIONS, XL_MODELS

def count_images(directory):
    files_grabbed = []
    for files in VALID_IMAGE_EXTENSIONS:
        files_grabbed.extend(glob.glob(os.path.join(directory, '*' + files)))
    return len(files_grabbed)

def run_dreambooth_command_factory(args):
    return RunAutoTrainDreamboothCommand(args)

class RunAutoTrainDreamboothCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = [{'arg': '--revision', 'help': 'Model revision to use for training', 'required': False, 'type': str}, {'arg': '--tokenizer', 'help': 'Tokenizer to use for training', 'required': False, 'type': str}, {'arg': '--image-path', 'help': 'Path to the images', 'required': True, 'type': str}, {'arg': '--class-image-path', 'help': 'Path to the class images', 'required': False, 'type': str}, {'arg': '--prompt', 'help': 'Instance prompt', 'required': True, 'type': str}, {'arg': '--class-prompt', 'help': 'Class prompt', 'required': False, 'type': str}, {'arg': '--num-class-images', 'help': 'Number of class images', 'required': False, 'default': 100, 'type': int}, {'arg': '--class-labels-conditioning', 'help': 'Class labels conditioning', 'required': False, 'type': str}, {'arg': '--prior-preservation', 'help': 'With prior preservation', 'required': False, 'action': 'store_true'}, {'arg': '--prior-loss-weight', 'help': 'Prior loss weight', 'required': False, 'default': 1.0, 'type': float}, {'arg': '--resolution', 'help': 'Resolution', 'required': True, 'type': int}, {'arg': '--center-crop', 'help': 'Center crop', 'required': False, 'action': 'store_true'}, {'arg': '--train-text-encoder', 'help': 'Train text encoder', 'required': False, 'action': 'store_true'}, {'arg': '--sample-batch-size', 'help': 'Sample batch size', 'required': False, 'default': 4, 'type': int}, {'arg': '--num-steps', 'help': 'Max train steps', 'required': False, 'type': int}, {'arg': '--checkpointing-steps', 'help': 'Checkpointing steps', 'required': False, 'default': 100000, 'type': int}, {'arg': '--resume-from-checkpoint', 'help': 'Resume from checkpoint', 'required': False, 'type': str}, {'arg': '--scale-lr', 'help': 'Scale learning rate', 'required': False, 'action': 'store_true'}, {'arg': '--scheduler', 'help': 'Learning rate scheduler', 'required': False, 'default': 'constant'}, {'arg': '--warmup-steps', 'help': 'Learning rate warmup steps', 'required': False, 'default': 0, 'type': int}, {'arg': '--num-cycles', 'help': 'Learning rate num cycles', 'required': False, 'default': 1, 'type': int}, {'arg': '--lr-power', 'help': 'Learning rate power', 'required': False, 'default': 1.0, 'type': float}, {'arg': '--dataloader-num-workers', 'help': 'Dataloader num workers', 'required': False, 'default': 0, 'type': int}, {'arg': '--use-8bit-adam', 'help': 'Use 8bit adam', 'required': False, 'action': 'store_true'}, {'arg': '--adam-beta1', 'help': 'Adam beta 1', 'required': False, 'default': 0.9, 'type': float}, {'arg': '--adam-beta2', 'help': 'Adam beta 2', 'required': False, 'default': 0.999, 'type': float}, {'arg': '--adam-weight-decay', 'help': 'Adam weight decay', 'required': False, 'default': 0.01, 'type': float}, {'arg': '--adam-epsilon', 'help': 'Adam epsilon', 'required': False, 'default': 1e-08, 'type': float}, {'arg': '--max-grad-norm', 'help': 'Max grad norm', 'required': False, 'default': 1.0, 'type': float}, {'arg': '--allow-tf32', 'help': 'Allow TF32', 'required': False, 'action': 'store_true'}, {'arg': '--prior-generation-precision', 'help': 'Prior generation precision', 'required': False, 'type': str}, {'arg': '--local-rank', 'help': 'Local rank', 'required': False, 'default': -1, 'type': int}, {'arg': '--xformers', 'help': 'Enable xformers memory efficient attention', 'required': False, 'action': 'store_true'}, {'arg': '--pre-compute-text-embeddings', 'help': 'Pre compute text embeddings', 'required': False, 'action': 'store_true'}, {'arg': '--tokenizer-max-length', 'help': 'Tokenizer max length', 'required': False, 'type': int}, {'arg': '--text-encoder-use-attention-mask', 'help': 'Text encoder use attention mask', 'required': False, 'action': 'store_true'}, {'arg': '--rank', 'help': 'Rank', 'required': False, 'default': 4, 'type': int}, {'arg': '--xl', 'help': 'XL', 'required': False, 'action': 'store_true'}, {'arg': '--mixed-precision', 'help': 'mixed precision, fp16, bf16, none', 'required': False, 'type': str, 'default': 'none'}, {'arg': '--validation-prompt', 'help': 'Validation prompt', 'required': False, 'type': str}, {'arg': '--num-validation-images', 'help': 'Number of validation images', 'required': False, 'default': 4, 'type': int}, {'arg': '--validation-epochs', 'help': 'Validation epochs', 'required': False, 'default': 50, 'type': int}, {'arg': '--checkpoints-total-limit', 'help': 'Checkpoints total limit', 'required': False, 'type': int}, {'arg': '--validation-images', 'help': 'Validation images', 'required': False, 'type': str}, {'arg': '--logging', 'help': 'Logging using tensorboard', 'required': False, 'action': 'store_true'}]
        arg_list = common_args() + arg_list
        run_dreambooth_parser = parser.add_parser('dreambooth', description='✨ Run AutoTrain DreamBooth Training')
        for arg in arg_list:
            if 'action' in arg:
                run_dreambooth_parser.add_argument(arg['arg'], help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_dreambooth_parser.add_argument(arg['arg'], help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_dreambooth_parser.set_defaults(func=run_dreambooth_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['center_crop', 'train_text_encoder', 'disable_gradient_checkpointing', 'scale_lr', 'use_8bit_adam', 'allow_tf32', 'xformers', 'pre_compute_text_embeddings', 'text_encoder_use_attention_mask', 'xl', 'push_to_hub', 'logging', 'prior_preservation']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if not os.path.isdir(self.args.image_path):
            raise ValueError('❌ Please specify a valid image directory')
        num_images = count_images(self.args.image_path)
        if num_images == 0:
            raise ValueError('❌ Please specify a valid image directory')
        if self.args.push_to_hub:
            if self.args.username is None:
                raise ValueError('❌ Please specify a username to push to hub')
        if self.args.model in XL_MODELS:
            self.args.xl = True
        if self.args.backend.startswith('spaces') or self.args.backend.startswith('ep-'):
            if not self.args.push_to_hub:
                raise ValueError('Push to hub must be specified for spaces backend')
            if self.args.username is None:
                raise ValueError('Username must be specified for spaces backend')
            if self.args.token is None:
                raise ValueError('Token must be specified for spaces backend')

    def run(self):
        logger.info('Running DreamBooth Training')
        params = DreamBoothTrainingParams(**vars(self.args))
        params = dreambooth_munge_data(params, local=self.args.backend.startswith('local'))
        project = AutoTrainProject(params=params, backend=self.args.backend)
        job_id = project.create()
        logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_extractive_qa.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import ext_qa_munge_data, get_field_info
from autotrain.project import AutoTrainProject
from autotrain.trainers.extractive_question_answering.params import ExtractiveQuestionAnsweringParams
from . import BaseAutoTrainCommand

def run_extractive_qa_command_factory(args):
    return RunAutoTrainExtractiveQACommand(args)

class RunAutoTrainExtractiveQACommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(ExtractiveQuestionAnsweringParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend to use for training', 'required': False, 'default': 'local'}] + arg_list
        arg_list = [arg for arg in arg_list if arg['arg'] != '--disable-gradient-checkpointing']
        run_extractive_qa_parser = parser.add_parser('extractive-qa', description='✨ Run AutoTrain Extractive Question Answering')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_extractive_qa_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_extractive_qa_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_extractive_qa_parser.set_defaults(func=run_extractive_qa_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'auto_find_batch_size', 'push_to_hub']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')

    def run(self):
        logger.info('Running Extractive Question Answering')
        if self.args.train:
            params = ExtractiveQuestionAnsweringParams(**vars(self.args))
            params = ext_qa_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_image_classification.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, img_clf_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.image_classification.params import ImageClassificationParams
from . import BaseAutoTrainCommand

def run_image_classification_command_factory(args):
    return RunAutoTrainImageClassificationCommand(args)

class RunAutoTrainImageClassificationCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(ImageClassificationParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        run_image_classification_parser = parser.add_parser('image-classification', description='✨ Run AutoTrain Image Classification')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_image_classification_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_image_classification_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_image_classification_parser.set_defaults(func=run_image_classification_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'auto_find_batch_size', 'push_to_hub']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')
        if self.args.backend.startswith('spaces') or self.args.backend.startswith('ep-'):
            if not self.args.push_to_hub:
                raise ValueError('Push to hub must be specified for spaces backend')
            if self.args.username is None:
                raise ValueError('Username must be specified for spaces backend')
            if self.args.token is None:
                raise ValueError('Token must be specified for spaces backend')

    def run(self):
        logger.info('Running Image Classification')
        if self.args.train:
            params = ImageClassificationParams(**vars(self.args))
            params = img_clf_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_image_regression.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, img_reg_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.image_regression.params import ImageRegressionParams
from . import BaseAutoTrainCommand

def run_image_regression_command_factory(args):
    return RunAutoTrainImageRegressionCommand(args)

class RunAutoTrainImageRegressionCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(ImageRegressionParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        run_image_regression_parser = parser.add_parser('image-regression', description='✨ Run AutoTrain Image Regression')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_image_regression_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_image_regression_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_image_regression_parser.set_defaults(func=run_image_regression_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'auto_find_batch_size', 'push_to_hub']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')
        if self.args.backend.startswith('spaces') or self.args.backend.startswith('ep-'):
            if not self.args.push_to_hub:
                raise ValueError('Push to hub must be specified for spaces backend')
            if self.args.username is None:
                raise ValueError('Username must be specified for spaces backend')
            if self.args.token is None:
                raise ValueError('Token must be specified for spaces backend')

    def run(self):
        logger.info('Running Image Regression')
        if self.args.train:
            params = ImageRegressionParams(**vars(self.args))
            params = img_reg_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_llm.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, llm_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.clm.params import LLMTrainingParams
from . import BaseAutoTrainCommand

def run_llm_command_factory(args):
    return RunAutoTrainLLMCommand(args)

class RunAutoTrainLLMCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(LLMTrainingParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        arg_list = [arg for arg in arg_list if arg['arg'] != '--block-size']
        arg_list.append({'arg': '--block_size', 'help': 'Block size', 'required': False, 'type': str, 'default': '1024', 'alias': ['--block-size']})
        run_llm_parser = parser.add_parser('llm', description='✨ Run AutoTrain LLM')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_llm_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_llm_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_llm_parser.set_defaults(func=run_llm_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'add_eos_token', 'peft', 'auto_find_batch_size', 'push_to_hub', 'merge_adapter', 'use_flash_attention_2', 'disable_gradient_checkpointing']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        block_size_split = self.args.block_size.strip().split(',')
        if len(block_size_split) == 1:
            self.args.block_size = int(block_size_split[0])
        elif len(block_size_split) > 1:
            self.args.block_size = [int(x.strip()) for x in block_size_split]
        else:
            raise ValueError('Invalid block size')
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Usernamemust be specified for push to hub')
                if self.args.token is None:
                    raise ValueError('Token must be specified for push to hub')
            if self.args.backend.startswith('spaces') or self.args.backend.startswith('ep-'):
                if not self.args.push_to_hub:
                    raise ValueError('Push to hub must be specified for spaces backend')
                if self.args.username is None:
                    raise ValueError('Username must be specified for spaces backend')
                if self.args.token is None:
                    raise ValueError('Token must be specified for spaces backend')
        if self.args.deploy:
            raise NotImplementedError('Deploy is not implemented yet')
        if self.args.inference:
            raise NotImplementedError('Inference is not implemented yet')

    def run(self):
        logger.info('Running LLM')
        if self.args.train:
            params = LLMTrainingParams(**vars(self.args))
            params = llm_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_object_detection.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, img_obj_detect_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.object_detection.params import ObjectDetectionParams
from . import BaseAutoTrainCommand

def run_object_detection_command_factory(args):
    return RunAutoTrainObjectDetectionCommand(args)

class RunAutoTrainObjectDetectionCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(ObjectDetectionParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        run_object_detection_parser = parser.add_parser('object-detection', description='✨ Run AutoTrain Object Detection')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_object_detection_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_object_detection_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_object_detection_parser.set_defaults(func=run_object_detection_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'auto_find_batch_size', 'push_to_hub']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')
        if self.args.backend.startswith('spaces') or self.args.backend.startswith('ep-'):
            if not self.args.push_to_hub:
                raise ValueError('Push to hub must be specified for spaces backend')
            if self.args.username is None:
                raise ValueError('Username must be specified for spaces backend')
            if self.args.token is None:
                raise ValueError('Token must be specified for spaces backend')

    def run(self):
        logger.info('Running Object Detection')
        if self.args.train:
            params = ObjectDetectionParams(**vars(self.args))
            params = img_obj_detect_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_sent_tranformers.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, sent_transformers_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.sent_transformers.params import SentenceTransformersParams
from . import BaseAutoTrainCommand

def run_sentence_transformers_command_factory(args):
    return RunAutoTrainSentenceTransformersCommand(args)

class RunAutoTrainSentenceTransformersCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(SentenceTransformersParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        run_sentence_transformers_parser = parser.add_parser('sentence-transformers', description='✨ Run AutoTrain Sentence Transformers')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_sentence_transformers_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_sentence_transformers_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_sentence_transformers_parser.set_defaults(func=run_sentence_transformers_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'auto_find_batch_size', 'push_to_hub']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')
        if self.args.backend.startswith('spaces') or self.args.backend.startswith('ep-'):
            if not self.args.push_to_hub:
                raise ValueError('Push to hub must be specified for spaces backend')
            if self.args.username is None:
                raise ValueError('Username must be specified for spaces backend')
            if self.args.token is None:
                raise ValueError('Token must be specified for spaces backend')

    def run(self):
        logger.info('Running Sentence Transformers...')
        if self.args.train:
            params = SentenceTransformersParams(**vars(self.args))
            params = sent_transformers_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_seq2seq.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, seq2seq_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.seq2seq.params import Seq2SeqParams
from . import BaseAutoTrainCommand

def run_seq2seq_command_factory(args):
    return RunAutoTrainSeq2SeqCommand(args)

class RunAutoTrainSeq2SeqCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(Seq2SeqParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        run_seq2seq_parser = parser.add_parser('seq2seq', description='✨ Run AutoTrain Seq2Seq')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_seq2seq_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_seq2seq_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_seq2seq_parser.set_defaults(func=run_seq2seq_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'auto_find_batch_size', 'push_to_hub', 'peft']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')

    def run(self):
        logger.info('Running Seq2Seq Classification')
        if self.args.train:
            params = Seq2SeqParams(**vars(self.args))
            params = seq2seq_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_spacerunner.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.backends.base import AVAILABLE_HARDWARE
from autotrain.backends.spaces import SpaceRunner
from autotrain.trainers.generic.params import GenericParams
from autotrain.trainers.generic.utils import create_dataset_repo
from . import BaseAutoTrainCommand
BACKEND_CHOICES = list(AVAILABLE_HARDWARE.keys())
BACKEND_CHOICES = [b for b in BACKEND_CHOICES if b.startswith('spaces-')]

def run_spacerunner_command_factory(args):
    return RunAutoTrainSpaceRunnerCommand(args)

class RunAutoTrainSpaceRunnerCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = [{'arg': '--project-name', 'help': 'Name of the project. Must be unique.', 'required': True, 'type': str}, {'arg': '--script-path', 'help': 'Path to the script', 'required': True, 'type': str}, {'arg': '--username', 'help': 'Hugging Face Username, can also be an organization name', 'required': True, 'type': str}, {'arg': '--token', 'help': 'Hugging Face API Token', 'required': True, 'type': str}, {'arg': '--backend', 'help': 'Hugging Face backend to use', 'required': True, 'type': str, 'choices': BACKEND_CHOICES}, {'arg': '--env', 'help': 'Environment variables, e.g. --env FOO=bar;FOO2=bar2;FOO3=bar3', 'required': False, 'type': str}, {'arg': '--args', 'help': 'Arguments to pass to the script, e.g. --args foo=bar;foo2=bar2;foo3=bar3;store_true_arg', 'required': False, 'type': str}]
        run_spacerunner_parser = parser.add_parser('spacerunner', description='✨ Run AutoTrain SpaceRunner')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_spacerunner_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'), choices=arg.get('choices'))
            else:
                run_spacerunner_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_spacerunner_parser.set_defaults(func=run_spacerunner_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = []
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        env_vars = {}
        if self.args.env:
            for env_name_value in self.args.env.split(';'):
                if len(env_name_value.split('=')) == 2:
                    env_vars[env_name_value.split('=')[0]] = env_name_value.split('=')[1]
                else:
                    raise ValueError('Invalid environment variable format.')
        self.args.env = env_vars
        app_args = {}
        store_true_args = []
        if self.args.args:
            for arg_name_value in self.args.args.split(';'):
                if len(arg_name_value.split('=')) == 1:
                    store_true_args.append(arg_name_value)
                elif len(arg_name_value.split('=')) == 2:
                    app_args[arg_name_value.split('=')[0]] = arg_name_value.split('=')[1]
                else:
                    raise ValueError('Invalid argument format.')
        for arg_name in store_true_args:
            app_args[arg_name] = ''
        self.args.args = app_args

    def run(self):
        dataset_id = create_dataset_repo(username=self.args.username, project_name=self.args.project_name, script_path=self.args.script_path, token=self.args.token)
        params = GenericParams(project_name=self.args.project_name, data_path=dataset_id, username=self.args.username, token=self.args.token, script_path=self.args.script_path, env=self.args.env, args=self.args.args)
        project = SpaceRunner(params=params, backend=self.args.backend)
        job_id = project.create()
        logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_tabular.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, tabular_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.tabular.params import TabularParams
from . import BaseAutoTrainCommand

def run_tabular_command_factory(args):
    return RunAutoTrainTabularCommand(args)

class RunAutoTrainTabularCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(TabularParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        remove_args = ['--disable_gradient_checkpointing', '--gradient_accumulation', '--epochs', '--log', '--lr']
        arg_list = [arg for arg in arg_list if arg['arg'] not in remove_args]
        run_tabular_parser = parser.add_parser('tabular', description='✨ Run AutoTrain Tabular Data Training')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_tabular_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_tabular_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_tabular_parser.set_defaults(func=run_tabular_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'push_to_hub']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')
        self.args.target_columns = [k.strip() for k in self.args.target_columns.split(',')]

    def run(self):
        logger.info('Running Tabular Training')
        if self.args.train:
            params = TabularParams(**vars(self.args))
            params = tabular_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_text_classification.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, text_clf_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.text_classification.params import TextClassificationParams
from . import BaseAutoTrainCommand

def run_text_classification_command_factory(args):
    return RunAutoTrainTextClassificationCommand(args)

class RunAutoTrainTextClassificationCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(TextClassificationParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        arg_list = [arg for arg in arg_list if arg['arg'] != '--disable-gradient-checkpointing']
        run_text_classification_parser = parser.add_parser('text-classification', description='✨ Run AutoTrain Text Classification')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_text_classification_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_text_classification_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_text_classification_parser.set_defaults(func=run_text_classification_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'auto_find_batch_size', 'push_to_hub']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')

    def run(self):
        logger.info('Running Text Classification')
        if self.args.train:
            params = TextClassificationParams(**vars(self.args))
            params = text_clf_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_text_regression.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, text_reg_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.text_regression.params import TextRegressionParams
from . import BaseAutoTrainCommand

def run_text_regression_command_factory(args):
    return RunAutoTrainTextRegressionCommand(args)

class RunAutoTrainTextRegressionCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(TextRegressionParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        arg_list = [arg for arg in arg_list if arg['arg'] != '--disable-gradient-checkpointing']
        run_text_regression_parser = parser.add_parser('text-regression', description='✨ Run AutoTrain Text Regression')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_text_regression_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_text_regression_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_text_regression_parser.set_defaults(func=run_text_regression_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'auto_find_batch_size', 'push_to_hub']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')

    def run(self):
        logger.info('Running Text Regression')
        if self.args.train:
            params = TextRegressionParams(**vars(self.args))
            params = text_reg_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_token_classification.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, token_clf_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.token_classification.params import TokenClassificationParams
from . import BaseAutoTrainCommand

def run_token_classification_command_factory(args):
    return RunAutoTrainTokenClassificationCommand(args)

class RunAutoTrainTokenClassificationCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(TokenClassificationParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        arg_list = [arg for arg in arg_list if arg['arg'] != '--disable-gradient-checkpointing']
        run_token_classification_parser = parser.add_parser('token-classification', description='✨ Run AutoTrain Token Classification')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_token_classification_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_token_classification_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_token_classification_parser.set_defaults(func=run_token_classification_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'auto_find_batch_size', 'push_to_hub']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')

    def run(self):
        logger.info('Running Token Classification')
        if self.args.train:
            params = TokenClassificationParams(**vars(self.args))
            params = token_clf_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/run_tools.py
from argparse import ArgumentParser
from . import BaseAutoTrainCommand

def run_tools_command_factory(args):
    return RunAutoTrainToolsCommand(args)

class RunAutoTrainToolsCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        run_app_parser = parser.add_parser('tools', help='Run AutoTrain tools')
        subparsers = run_app_parser.add_subparsers(title='tools', dest='tool_name')
        merge_llm_parser = subparsers.add_parser('merge-llm-adapter', help='Merge LLM Adapter tool')
        merge_llm_parser.add_argument('--base-model-path', type=str, help='Base model path')
        merge_llm_parser.add_argument('--adapter-path', type=str, help='Adapter path')
        merge_llm_parser.add_argument('--token', type=str, help='Token', default=None, required=False)
        merge_llm_parser.add_argument('--pad-to-multiple-of', type=int, help='Pad to multiple of', default=None, required=False)
        merge_llm_parser.add_argument('--output-folder', type=str, help='Output folder', required=False, default=None)
        merge_llm_parser.add_argument('--push-to-hub', action='store_true', help='Push to Hugging Face Hub', required=False)
        merge_llm_parser.set_defaults(func=run_tools_command_factory, merge_llm_adapter=True)
        convert_to_kohya_parser = subparsers.add_parser('convert_to_kohya', help='Convert to Kohya tool')
        convert_to_kohya_parser.add_argument('--input-path', type=str, help='Input path')
        convert_to_kohya_parser.add_argument('--output-path', type=str, help='Output path')
        convert_to_kohya_parser.set_defaults(func=run_tools_command_factory, convert_to_kohya=True)

    def __init__(self, args):
        self.args = args

    def run(self):
        if getattr(self.args, 'merge_llm_adapter', False):
            self.run_merge_llm_adapter()
        if getattr(self.args, 'convert_to_kohya', False):
            self.run_convert_to_kohya()

    def run_merge_llm_adapter(self):
        from autotrain.tools.merge_adapter import merge_llm_adapter
        merge_llm_adapter(base_model_path=self.args.base_model_path, adapter_path=self.args.adapter_path, token=self.args.token, output_folder=self.args.output_folder, pad_to_multiple_of=self.args.pad_to_multiple_of, push_to_hub=self.args.push_to_hub)

    def run_convert_to_kohya(self):
        from autotrain.tools.convert_to_kohya import convert_to_kohya
        convert_to_kohya(input_path=self.args.input_path, output_path=self.args.output_path)

# File: autotrain-advanced-main/src/autotrain/cli/run_vlm.py
from argparse import ArgumentParser
from autotrain import logger
from autotrain.cli.utils import get_field_info, vlm_munge_data
from autotrain.project import AutoTrainProject
from autotrain.trainers.vlm.params import VLMTrainingParams
from . import BaseAutoTrainCommand

def run_vlm_command_factory(args):
    return RunAutoTrainVLMCommand(args)

class RunAutoTrainVLMCommand(BaseAutoTrainCommand):

    @staticmethod
    def register_subcommand(parser: ArgumentParser):
        arg_list = get_field_info(VLMTrainingParams)
        arg_list = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--backend', 'help': 'Backend', 'required': False, 'type': str, 'default': 'local'}] + arg_list
        run_image_regression_parser = parser.add_parser('vlm', description='✨ Run AutoTrain VLM')
        for arg in arg_list:
            names = [arg['arg']] + arg.get('alias', [])
            if 'action' in arg:
                run_image_regression_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), action=arg.get('action'), default=arg.get('default'))
            else:
                run_image_regression_parser.add_argument(*names, dest=arg['arg'].replace('--', '').replace('-', '_'), help=arg['help'], required=arg.get('required', False), type=arg.get('type'), default=arg.get('default'), choices=arg.get('choices'))
        run_image_regression_parser.set_defaults(func=run_vlm_command_factory)

    def __init__(self, args):
        self.args = args
        store_true_arg_names = ['train', 'deploy', 'inference', 'auto_find_batch_size', 'push_to_hub']
        for arg_name in store_true_arg_names:
            if getattr(self.args, arg_name) is None:
                setattr(self.args, arg_name, False)
        if self.args.train:
            if self.args.project_name is None:
                raise ValueError('Project name must be specified')
            if self.args.data_path is None:
                raise ValueError('Data path must be specified')
            if self.args.model is None:
                raise ValueError('Model must be specified')
            if self.args.push_to_hub:
                if self.args.username is None:
                    raise ValueError('Username must be specified for push to hub')
        else:
            raise ValueError('Must specify --train, --deploy or --inference')
        if self.args.backend.startswith('spaces') or self.args.backend.startswith('ep-'):
            if not self.args.push_to_hub:
                raise ValueError('Push to hub must be specified for spaces backend')
            if self.args.username is None:
                raise ValueError('Username must be specified for spaces backend')
            if self.args.token is None:
                raise ValueError('Token must be specified for spaces backend')

    def run(self):
        logger.info('Running Image Regression')
        if self.args.train:
            params = VLMTrainingParams(**vars(self.args))
            params = vlm_munge_data(params, local=self.args.backend.startswith('local'))
            project = AutoTrainProject(params=params, backend=self.args.backend)
            job_id = project.create()
            logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/cli/utils.py
import os
from typing import Any, Type
from autotrain.backends.base import AVAILABLE_HARDWARE
from autotrain.dataset import AutoTrainDataset, AutoTrainDreamboothDataset, AutoTrainImageClassificationDataset, AutoTrainImageRegressionDataset, AutoTrainObjectDetectionDataset, AutoTrainVLMDataset

def common_args():
    args = [{'arg': '--train', 'help': 'Command to train the model', 'required': False, 'action': 'store_true'}, {'arg': '--deploy', 'help': 'Command to deploy the model (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--inference', 'help': 'Command to run inference (limited availability)', 'required': False, 'action': 'store_true'}, {'arg': '--username', 'help': 'Hugging Face Hub Username', 'required': False, 'type': str}, {'arg': '--backend', 'help': 'Backend to use: default or spaces. Spaces backend requires push_to_hub & username. Advanced users only.', 'required': False, 'type': str, 'default': 'local', 'choices': AVAILABLE_HARDWARE.keys()}, {'arg': '--token', 'help': 'Your Hugging Face API token. Token must have write access to the model hub.', 'required': False, 'type': str}, {'arg': '--push-to-hub', 'help': 'Push to hub after training will push the trained model to the Hugging Face model hub.', 'required': False, 'action': 'store_true'}, {'arg': '--model', 'help': 'Base model to use for training', 'required': True, 'type': str}, {'arg': '--project-name', 'help': 'Output directory / repo id for trained model (must be unique on hub)', 'required': True, 'type': str}, {'arg': '--data-path', 'help': 'Train dataset to use. When using cli, this should be a directory path containing training and validation data in appropriate formats', 'required': False, 'type': str}, {'arg': '--train-split', 'help': 'Train dataset split to use', 'required': False, 'type': str, 'default': 'train'}, {'arg': '--valid-split', 'help': 'Validation dataset split to use', 'required': False, 'type': str, 'default': None}, {'arg': '--batch-size', 'help': 'Training batch size to use', 'required': False, 'type': int, 'default': 2, 'alias': ['--train-batch-size']}, {'arg': '--seed', 'help': 'Random seed for reproducibility', 'required': False, 'default': 42, 'type': int}, {'arg': '--epochs', 'help': 'Number of training epochs', 'required': False, 'default': 1, 'type': int}, {'arg': '--gradient-accumulation', 'help': 'Gradient accumulation steps', 'required': False, 'default': 1, 'type': int, 'alias': ['--gradient-accumulation']}, {'arg': '--disable-gradient-checkpointing', 'help': 'Disable gradient checkpointing', 'required': False, 'action': 'store_true', 'alias': ['--disable-gradient-checkpointing', '--disable-gc']}, {'arg': '--lr', 'help': 'Learning rate', 'required': False, 'default': 0.0005, 'type': float}, {'arg': '--log', 'help': 'Use experiment tracking', 'required': False, 'type': str, 'default': 'none', 'choices': ['none', 'wandb', 'tensorboard']}]
    return args

def python_type_from_schema_field(field_data: dict) -> Type:
    type_map = {'string': str, 'number': float, 'integer': int, 'boolean': bool}
    field_type = field_data.get('type')
    if field_type:
        return type_map.get(field_type, str)
    elif 'anyOf' in field_data:
        for type_option in field_data['anyOf']:
            if type_option['type'] != 'null':
                return type_map.get(type_option['type'], str)
    return str

def get_default_value(field_data: dict) -> Any:
    return field_data['default']

def get_field_info(params_class):
    schema = params_class.model_json_schema()
    properties = schema.get('properties', {})
    field_info = []
    for (field_name, field_data) in properties.items():
        temp_info = {'arg': f"--{field_name.replace('_', '-')}", 'alias': [f'--{field_name}', f"--{field_name.replace('_', '-')}"], 'type': python_type_from_schema_field(field_data), 'help': field_data.get('title', ''), 'default': get_default_value(field_data)}
        if temp_info['type'] == bool:
            temp_info['action'] = 'store_true'
        field_info.append(temp_info)
    return field_info

def tabular_munge_data(params, local):
    if isinstance(params.target_columns, str):
        col_map_label = [params.target_columns]
    else:
        col_map_label = params.target_columns
    task = params.task
    if task == 'classification' and len(col_map_label) > 1:
        task = 'tabular_multi_label_classification'
    elif task == 'classification' and len(col_map_label) == 1:
        task = 'tabular_multi_class_classification'
    elif task == 'regression' and len(col_map_label) > 1:
        task = 'tabular_multi_column_regression'
    elif task == 'regression' and len(col_map_label) == 1:
        task = 'tabular_single_column_regression'
    else:
        raise Exception('Please select a valid task.')
    exts = ['csv', 'jsonl']
    ext_to_use = None
    for ext in exts:
        path = f'{params.data_path}/{params.train_split}.{ext}'
        if os.path.exists(path):
            ext_to_use = ext
            break
    train_data_path = f'{params.data_path}/{params.train_split}.{ext_to_use}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}.{ext_to_use}'
    else:
        valid_data_path = None
    if os.path.exists(train_data_path):
        dset = AutoTrainDataset(train_data=[train_data_path], task=task, token=params.token, project_name=params.project_name, username=params.username, column_mapping={'id': params.id_column, 'label': col_map_label}, valid_data=[valid_data_path] if valid_data_path is not None else None, percent_valid=None, local=local, ext=ext_to_use)
        params.data_path = dset.prepare()
        params.valid_split = 'validation'
        params.id_column = 'autotrain_id'
        if len(col_map_label) == 1:
            params.target_columns = ['autotrain_label']
        else:
            params.target_columns = [f'autotrain_label_{i}' for i in range(len(col_map_label))]
    return params

def llm_munge_data(params, local):
    exts = ['csv', 'jsonl']
    ext_to_use = None
    for ext in exts:
        path = f'{params.data_path}/{params.train_split}.{ext}'
        if os.path.exists(path):
            ext_to_use = ext
            break
    train_data_path = f'{params.data_path}/{params.train_split}.{ext_to_use}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}.{ext_to_use}'
    else:
        valid_data_path = None
    if os.path.exists(train_data_path):
        col_map = {'text': params.text_column}
        if params.rejected_text_column is not None:
            col_map['rejected_text'] = params.rejected_text_column
        if params.prompt_text_column is not None:
            col_map['prompt'] = params.prompt_text_column
        dset = AutoTrainDataset(train_data=[train_data_path], task='lm_training', token=params.token, project_name=params.project_name, username=params.username, column_mapping=col_map, valid_data=[valid_data_path] if valid_data_path is not None else None, percent_valid=None, local=local, ext=ext_to_use)
        params.data_path = dset.prepare()
        params.valid_split = None
        params.text_column = 'autotrain_text'
        params.rejected_text_column = 'autotrain_rejected_text'
        params.prompt_text_column = 'autotrain_prompt'
    return params

def seq2seq_munge_data(params, local):
    exts = ['csv', 'jsonl']
    ext_to_use = None
    for ext in exts:
        path = f'{params.data_path}/{params.train_split}.{ext}'
        if os.path.exists(path):
            ext_to_use = ext
            break
    train_data_path = f'{params.data_path}/{params.train_split}.{ext_to_use}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}.{ext_to_use}'
    else:
        valid_data_path = None
    if os.path.exists(train_data_path):
        dset = AutoTrainDataset(train_data=[train_data_path], task='seq2seq', token=params.token, project_name=params.project_name, username=params.username, column_mapping={'text': params.text_column, 'label': params.target_column}, valid_data=[valid_data_path] if valid_data_path is not None else None, percent_valid=None, local=local, ext=ext_to_use)
        params.data_path = dset.prepare()
        params.valid_split = 'validation'
        params.text_column = 'autotrain_text'
        params.target_column = 'autotrain_label'
    return params

def text_clf_munge_data(params, local):
    exts = ['csv', 'jsonl']
    ext_to_use = None
    for ext in exts:
        path = f'{params.data_path}/{params.train_split}.{ext}'
        if os.path.exists(path):
            ext_to_use = ext
            break
    train_data_path = f'{params.data_path}/{params.train_split}.{ext_to_use}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}.{ext_to_use}'
    else:
        valid_data_path = None
    if os.path.exists(train_data_path):
        dset = AutoTrainDataset(train_data=[train_data_path], valid_data=[valid_data_path] if valid_data_path is not None else None, task='text_multi_class_classification', token=params.token, project_name=params.project_name, username=params.username, column_mapping={'text': params.text_column, 'label': params.target_column}, percent_valid=None, local=local, convert_to_class_label=True, ext=ext_to_use)
        params.data_path = dset.prepare()
        params.valid_split = 'validation'
        params.text_column = 'autotrain_text'
        params.target_column = 'autotrain_label'
    return params

def text_reg_munge_data(params, local):
    exts = ['csv', 'jsonl']
    ext_to_use = None
    for ext in exts:
        path = f'{params.data_path}/{params.train_split}.{ext}'
        if os.path.exists(path):
            ext_to_use = ext
            break
    train_data_path = f'{params.data_path}/{params.train_split}.{ext_to_use}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}.{ext_to_use}'
    else:
        valid_data_path = None
    if os.path.exists(train_data_path):
        dset = AutoTrainDataset(train_data=[train_data_path], valid_data=[valid_data_path] if valid_data_path is not None else None, task='text_single_column_regression', token=params.token, project_name=params.project_name, username=params.username, column_mapping={'text': params.text_column, 'label': params.target_column}, percent_valid=None, local=local, convert_to_class_label=False, ext=ext_to_use)
        params.data_path = dset.prepare()
        params.valid_split = 'validation'
        params.text_column = 'autotrain_text'
        params.target_column = 'autotrain_label'
    return params

def token_clf_munge_data(params, local):
    exts = ['csv', 'jsonl']
    ext_to_use = None
    for ext in exts:
        path = f'{params.data_path}/{params.train_split}.{ext}'
        if os.path.exists(path):
            ext_to_use = ext
            break
    train_data_path = f'{params.data_path}/{params.train_split}.{ext_to_use}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}.{ext_to_use}'
    else:
        valid_data_path = None
    if os.path.exists(train_data_path):
        dset = AutoTrainDataset(train_data=[train_data_path], valid_data=[valid_data_path] if valid_data_path is not None else None, task='text_token_classification', token=params.token, project_name=params.project_name, username=params.username, column_mapping={'text': params.tokens_column, 'label': params.tags_column}, percent_valid=None, local=local, convert_to_class_label=True, ext=ext_to_use)
        params.data_path = dset.prepare()
        params.valid_split = 'validation'
        params.text_column = 'autotrain_text'
        params.target_column = 'autotrain_label'
    return params

def img_clf_munge_data(params, local):
    train_data_path = f'{params.data_path}/{params.train_split}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}'
    else:
        valid_data_path = None
    if os.path.isdir(train_data_path):
        dset = AutoTrainImageClassificationDataset(train_data=train_data_path, valid_data=valid_data_path, token=params.token, project_name=params.project_name, username=params.username, local=local)
        params.data_path = dset.prepare()
        params.valid_split = 'validation'
        params.image_column = 'autotrain_image'
        params.target_column = 'autotrain_label'
    return params

def dreambooth_munge_data(params, local):
    if os.path.isdir(params.image_path):
        training_data = [os.path.join(params.image_path, f) for f in os.listdir(params.image_path)]
        dset = AutoTrainDreamboothDataset(concept_images=training_data, concept_name=params.prompt, token=params.token, project_name=params.project_name, username=params.username, local=local)
        params.image_path = dset.prepare()
    return params

def img_obj_detect_munge_data(params, local):
    train_data_path = f'{params.data_path}/{params.train_split}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}'
    else:
        valid_data_path = None
    if os.path.isdir(train_data_path):
        dset = AutoTrainObjectDetectionDataset(train_data=train_data_path, valid_data=valid_data_path, token=params.token, project_name=params.project_name, username=params.username, local=local)
        params.data_path = dset.prepare()
        params.valid_split = 'validation'
        params.image_column = 'autotrain_image'
        params.objects_column = 'autotrain_objects'
    return params

def sent_transformers_munge_data(params, local):
    exts = ['csv', 'jsonl']
    ext_to_use = None
    for ext in exts:
        path = f'{params.data_path}/{params.train_split}.{ext}'
        if os.path.exists(path):
            ext_to_use = ext
            break
    train_data_path = f'{params.data_path}/{params.train_split}.{ext_to_use}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}.{ext_to_use}'
    else:
        valid_data_path = None
    if os.path.exists(train_data_path):
        dset = AutoTrainDataset(train_data=[train_data_path], valid_data=[valid_data_path] if valid_data_path is not None else None, task='sentence_transformers', token=params.token, project_name=params.project_name, username=params.username, column_mapping={'sentence1': params.sentence1_column, 'sentence2': params.sentence2_column, 'sentence3': params.sentence3_column, 'target': params.target_column}, percent_valid=None, local=local, convert_to_class_label=True if params.trainer == 'pair_class' else False, ext=ext_to_use)
        params.data_path = dset.prepare()
        params.valid_split = 'validation'
        params.sentence1_column = 'autotrain_sentence1'
        params.sentence2_column = 'autotrain_sentence2'
        params.sentence3_column = 'autotrain_sentence3'
        params.target_column = 'autotrain_target'
    return params

def img_reg_munge_data(params, local):
    train_data_path = f'{params.data_path}/{params.train_split}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}'
    else:
        valid_data_path = None
    if os.path.isdir(train_data_path):
        dset = AutoTrainImageRegressionDataset(train_data=train_data_path, valid_data=valid_data_path, token=params.token, project_name=params.project_name, username=params.username, local=local)
        params.data_path = dset.prepare()
        params.valid_split = 'validation'
        params.image_column = 'autotrain_image'
        params.target_column = 'autotrain_label'
    return params

def vlm_munge_data(params, local):
    train_data_path = f'{params.data_path}/{params.train_split}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}'
    else:
        valid_data_path = None
    if os.path.exists(train_data_path):
        col_map = {'text': params.text_column}
        if params.prompt_text_column is not None:
            col_map['prompt'] = params.prompt_text_column
        dset = AutoTrainVLMDataset(train_data=train_data_path, token=params.token, project_name=params.project_name, username=params.username, column_mapping=col_map, valid_data=valid_data_path if valid_data_path is not None else None, percent_valid=None, local=local)
        params.data_path = dset.prepare()
        params.text_column = 'autotrain_text'
        params.image_column = 'autotrain_image'
        params.prompt_text_column = 'autotrain_prompt'
    return params

def ext_qa_munge_data(params, local):
    exts = ['csv', 'jsonl']
    ext_to_use = None
    for ext in exts:
        path = f'{params.data_path}/{params.train_split}.{ext}'
        if os.path.exists(path):
            ext_to_use = ext
            break
    train_data_path = f'{params.data_path}/{params.train_split}.{ext_to_use}'
    if params.valid_split is not None:
        valid_data_path = f'{params.data_path}/{params.valid_split}.{ext_to_use}'
    else:
        valid_data_path = None
    if os.path.exists(train_data_path):
        dset = AutoTrainDataset(train_data=[train_data_path], valid_data=[valid_data_path] if valid_data_path is not None else None, task='text_extractive_question_answering', token=params.token, project_name=params.project_name, username=params.username, column_mapping={'text': params.text_column, 'question': params.question_column, 'answer': params.answer_column}, percent_valid=None, local=local, convert_to_class_label=True, ext=ext_to_use)
        params.data_path = dset.prepare()
        params.valid_split = 'validation'
        params.text_column = 'autotrain_text'
        params.question_column = 'autotrain_question'
        params.answer_column = 'autotrain_answer'
    return params

# File: autotrain-advanced-main/src/autotrain/commands.py
import os
import shlex
import torch
from autotrain import logger
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams
from autotrain.trainers.extractive_question_answering.params import ExtractiveQuestionAnsweringParams
from autotrain.trainers.generic.params import GenericParams
from autotrain.trainers.image_classification.params import ImageClassificationParams
from autotrain.trainers.image_regression.params import ImageRegressionParams
from autotrain.trainers.object_detection.params import ObjectDetectionParams
from autotrain.trainers.sent_transformers.params import SentenceTransformersParams
from autotrain.trainers.seq2seq.params import Seq2SeqParams
from autotrain.trainers.tabular.params import TabularParams
from autotrain.trainers.text_classification.params import TextClassificationParams
from autotrain.trainers.text_regression.params import TextRegressionParams
from autotrain.trainers.token_classification.params import TokenClassificationParams
from autotrain.trainers.vlm.params import VLMTrainingParams

def launch_command(params):
    params.project_name = shlex.split(params.project_name)[0]
    cuda_available = torch.cuda.is_available()
    mps_available = torch.backends.mps.is_available()
    if cuda_available:
        num_gpus = torch.cuda.device_count()
    elif mps_available:
        num_gpus = 1
    else:
        num_gpus = 0
    if isinstance(params, LLMTrainingParams):
        if num_gpus == 0:
            logger.warning('No GPU found. Forcing training on CPU. This will be super slow!')
            cmd = ['accelerate', 'launch', '--cpu']
        elif num_gpus == 1:
            cmd = ['accelerate', 'launch', '--num_machines', '1', '--num_processes', '1']
        elif num_gpus == 2:
            cmd = ['accelerate', 'launch', '--multi_gpu', '--num_machines', '1', '--num_processes', '2']
        elif params.quantization in ('int8', 'int4') and params.peft and (params.mixed_precision == 'bf16'):
            cmd = ['accelerate', 'launch', '--multi_gpu', '--num_machines', '1', '--num_processes', str(num_gpus)]
        else:
            cmd = ['accelerate', 'launch', '--use_deepspeed', '--zero_stage', '3', '--offload_optimizer_device', 'none', '--offload_param_device', 'none', '--zero3_save_16bit_model', 'true', '--zero3_init_flag', 'true', '--deepspeed_multinode_launcher', 'standard', '--gradient_accumulation_steps', str(params.gradient_accumulation)]
        if num_gpus > 0:
            cmd.append('--mixed_precision')
            if params.mixed_precision == 'fp16':
                cmd.append('fp16')
            elif params.mixed_precision == 'bf16':
                cmd.append('bf16')
            else:
                cmd.append('no')
        cmd.extend(['-m', 'autotrain.trainers.clm', '--training_config', os.path.join(params.project_name, 'training_params.json')])
    elif isinstance(params, DreamBoothTrainingParams):
        cmd = ['python', '-m', 'autotrain.trainers.dreambooth', '--training_config', os.path.join(params.project_name, 'training_params.json')]
    elif isinstance(params, GenericParams):
        cmd = ['python', '-m', 'autotrain.trainers.generic', '--config', os.path.join(params.project_name, 'training_params.json')]
    elif isinstance(params, TabularParams):
        cmd = ['python', '-m', 'autotrain.trainers.tabular', '--training_config', os.path.join(params.project_name, 'training_params.json')]
    elif isinstance(params, TextClassificationParams) or isinstance(params, TextRegressionParams) or isinstance(params, SentenceTransformersParams) or isinstance(params, ExtractiveQuestionAnsweringParams):
        if num_gpus == 0:
            cmd = ['accelerate', 'launch', '--cpu']
        elif num_gpus == 1:
            cmd = ['accelerate', 'launch', '--num_machines', '1', '--num_processes', '1']
        else:
            cmd = ['accelerate', 'launch', '--multi_gpu', '--num_machines', '1', '--num_processes', str(num_gpus)]
        if num_gpus > 0:
            cmd.append('--mixed_precision')
            if params.mixed_precision == 'fp16':
                cmd.append('fp16')
            elif params.mixed_precision == 'bf16':
                cmd.append('bf16')
            else:
                cmd.append('no')
        if isinstance(params, TextRegressionParams):
            cmd.extend(['-m', 'autotrain.trainers.text_regression', '--training_config', os.path.join(params.project_name, 'training_params.json')])
        elif isinstance(params, SentenceTransformersParams):
            cmd.extend(['-m', 'autotrain.trainers.sent_transformers', '--training_config', os.path.join(params.project_name, 'training_params.json')])
        elif isinstance(params, ExtractiveQuestionAnsweringParams):
            cmd.extend(['-m', 'autotrain.trainers.extractive_question_answering', '--training_config', os.path.join(params.project_name, 'training_params.json')])
        else:
            cmd.extend(['-m', 'autotrain.trainers.text_classification', '--training_config', os.path.join(params.project_name, 'training_params.json')])
    elif isinstance(params, TokenClassificationParams):
        if num_gpus == 0:
            cmd = ['accelerate', 'launch', '--cpu']
        elif num_gpus == 1:
            cmd = ['accelerate', 'launch', '--num_machines', '1', '--num_processes', '1']
        else:
            cmd = ['accelerate', 'launch', '--multi_gpu', '--num_machines', '1', '--num_processes', str(num_gpus)]
        if num_gpus > 0:
            cmd.append('--mixed_precision')
            if params.mixed_precision == 'fp16':
                cmd.append('fp16')
            elif params.mixed_precision == 'bf16':
                cmd.append('bf16')
            else:
                cmd.append('no')
        cmd.extend(['-m', 'autotrain.trainers.token_classification', '--training_config', os.path.join(params.project_name, 'training_params.json')])
    elif isinstance(params, ImageClassificationParams) or isinstance(params, ObjectDetectionParams) or isinstance(params, ImageRegressionParams):
        if num_gpus == 0:
            cmd = ['accelerate', 'launch', '--cpu']
        elif num_gpus == 1:
            cmd = ['accelerate', 'launch', '--num_machines', '1', '--num_processes', '1']
        else:
            cmd = ['accelerate', 'launch', '--multi_gpu', '--num_machines', '1', '--num_processes', str(num_gpus)]
        if num_gpus > 0:
            cmd.append('--mixed_precision')
            if params.mixed_precision == 'fp16':
                cmd.append('fp16')
            elif params.mixed_precision == 'bf16':
                cmd.append('bf16')
            else:
                cmd.append('no')
        if isinstance(params, ObjectDetectionParams):
            cmd.extend(['-m', 'autotrain.trainers.object_detection', '--training_config', os.path.join(params.project_name, 'training_params.json')])
        elif isinstance(params, ImageRegressionParams):
            cmd.extend(['-m', 'autotrain.trainers.image_regression', '--training_config', os.path.join(params.project_name, 'training_params.json')])
        else:
            cmd.extend(['-m', 'autotrain.trainers.image_classification', '--training_config', os.path.join(params.project_name, 'training_params.json')])
    elif isinstance(params, Seq2SeqParams):
        if num_gpus == 0:
            logger.warning('No GPU found. Forcing training on CPU. This will be super slow!')
            cmd = ['accelerate', 'launch', '--cpu']
        elif num_gpus == 1:
            cmd = ['accelerate', 'launch', '--num_machines', '1', '--num_processes', '1']
        elif num_gpus == 2:
            cmd = ['accelerate', 'launch', '--multi_gpu', '--num_machines', '1', '--num_processes', '2']
        elif params.quantization in ('int8', 'int4') and params.peft and (params.mixed_precision == 'bf16'):
            cmd = ['accelerate', 'launch', '--multi_gpu', '--num_machines', '1', '--num_processes', str(num_gpus)]
        else:
            cmd = ['accelerate', 'launch', '--use_deepspeed', '--zero_stage', '3', '--offload_optimizer_device', 'none', '--offload_param_device', 'none', '--zero3_save_16bit_model', 'true', '--zero3_init_flag', 'true', '--deepspeed_multinode_launcher', 'standard', '--gradient_accumulation_steps', str(params.gradient_accumulation)]
        if num_gpus > 0:
            cmd.append('--mixed_precision')
            if params.mixed_precision == 'fp16':
                cmd.append('fp16')
            elif params.mixed_precision == 'bf16':
                cmd.append('bf16')
            else:
                cmd.append('no')
        cmd.extend(['-m', 'autotrain.trainers.seq2seq', '--training_config', os.path.join(params.project_name, 'training_params.json')])
    elif isinstance(params, VLMTrainingParams):
        if num_gpus == 0:
            logger.warning('No GPU found. Forcing training on CPU. This will be super slow!')
            cmd = ['accelerate', 'launch', '--cpu']
        elif num_gpus == 1:
            cmd = ['accelerate', 'launch', '--num_machines', '1', '--num_processes', '1']
        elif num_gpus == 2:
            cmd = ['accelerate', 'launch', '--multi_gpu', '--num_machines', '1', '--num_processes', '2']
        elif params.quantization in ('int8', 'int4') and params.peft and (params.mixed_precision == 'bf16'):
            cmd = ['accelerate', 'launch', '--multi_gpu', '--num_machines', '1', '--num_processes', str(num_gpus)]
        else:
            cmd = ['accelerate', 'launch', '--use_deepspeed', '--zero_stage', '3', '--offload_optimizer_device', 'none', '--offload_param_device', 'none', '--zero3_save_16bit_model', 'true', '--zero3_init_flag', 'true', '--deepspeed_multinode_launcher', 'standard', '--gradient_accumulation_steps', str(params.gradient_accumulation)]
        if num_gpus > 0:
            cmd.append('--mixed_precision')
            if params.mixed_precision == 'fp16':
                cmd.append('fp16')
            elif params.mixed_precision == 'bf16':
                cmd.append('bf16')
            else:
                cmd.append('no')
        cmd.extend(['-m', 'autotrain.trainers.vlm', '--training_config', os.path.join(params.project_name, 'training_params.json')])
    else:
        raise ValueError('Unsupported params type')
    logger.info(cmd)
    logger.info(params)
    return cmd

# File: autotrain-advanced-main/src/autotrain/dataset.py
import io
import os
import uuid
import zipfile
from dataclasses import dataclass
from typing import Any, Dict, List, Optional
import pandas as pd
from autotrain.preprocessor.dreambooth import DreamboothPreprocessor
from autotrain.preprocessor.tabular import TabularBinaryClassificationPreprocessor, TabularMultiClassClassificationPreprocessor, TabularMultiColumnRegressionPreprocessor, TabularMultiLabelClassificationPreprocessor, TabularSingleColumnRegressionPreprocessor
from autotrain.preprocessor.text import LLMPreprocessor, SentenceTransformersPreprocessor, Seq2SeqPreprocessor, TextBinaryClassificationPreprocessor, TextExtractiveQuestionAnsweringPreprocessor, TextMultiClassClassificationPreprocessor, TextSingleColumnRegressionPreprocessor, TextTokenClassificationPreprocessor
from autotrain.preprocessor.vision import ImageClassificationPreprocessor, ImageRegressionPreprocessor, ObjectDetectionPreprocessor
from autotrain.preprocessor.vlm import VLMPreprocessor

def remove_non_image_files(folder):
    allowed_extensions = {'.jpg', '.jpeg', '.png', '.JPG', '.JPEG', '.PNG', '.jsonl'}
    for (root, dirs, files) in os.walk(folder):
        for file in files:
            file_extension = os.path.splitext(file)[1]
            if file_extension.lower() not in allowed_extensions:
                file_path = os.path.join(root, file)
                os.remove(file_path)
                print(f'Removed file: {file_path}')
        for subfolder in dirs:
            remove_non_image_files(os.path.join(root, subfolder))

@dataclass
class AutoTrainDreamboothDataset:
    concept_images: List[Any]
    concept_name: str
    token: str
    project_name: str
    username: Optional[str] = None
    local: bool = False

    def __str__(self) -> str:
        info = f'Dataset: {self.project_name} ({self.task})\n'
        return info

    def __post_init__(self):
        self.task = 'dreambooth'

    @property
    def num_samples(self):
        return len(self.concept_images)

    def prepare(self):
        preprocessor = DreamboothPreprocessor(concept_images=self.concept_images, concept_name=self.concept_name, token=self.token, project_name=self.project_name, username=self.username, local=self.local)
        return preprocessor.prepare()

@dataclass
class AutoTrainImageClassificationDataset:
    train_data: str
    token: str
    project_name: str
    username: str
    valid_data: Optional[str] = None
    percent_valid: Optional[float] = None
    local: bool = False

    def __str__(self) -> str:
        info = f'Dataset: {self.project_name} ({self.task})\n'
        info += f'Train data: {self.train_data}\n'
        info += f'Valid data: {self.valid_data}\n'
        return info

    def __post_init__(self):
        self.task = 'image_multi_class_classification'
        if not self.valid_data and self.percent_valid is None:
            self.percent_valid = 0.2
        elif self.valid_data and self.percent_valid is not None:
            raise ValueError('You can only specify one of valid_data or percent_valid')
        elif self.valid_data:
            self.percent_valid = 0.0

    def prepare(self):
        valid_dir = None
        if not isinstance(self.train_data, str):
            cache_dir = os.environ.get('HF_HOME')
            if not cache_dir:
                cache_dir = os.path.join(os.path.expanduser('~'), '.cache', 'huggingface')
            random_uuid = uuid.uuid4()
            train_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
            os.makedirs(train_dir, exist_ok=True)
            self.train_data.seek(0)
            content = self.train_data.read()
            bytes_io = io.BytesIO(content)
            zip_ref = zipfile.ZipFile(bytes_io, 'r')
            zip_ref.extractall(train_dir)
            macosx_dir = os.path.join(train_dir, '__MACOSX')
            if os.path.exists(macosx_dir):
                os.system(f'rm -rf {macosx_dir}')
            remove_non_image_files(train_dir)
            if self.valid_data:
                random_uuid = uuid.uuid4()
                valid_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
                os.makedirs(valid_dir, exist_ok=True)
                self.valid_data.seek(0)
                content = self.valid_data.read()
                bytes_io = io.BytesIO(content)
                zip_ref = zipfile.ZipFile(bytes_io, 'r')
                zip_ref.extractall(valid_dir)
                macosx_dir = os.path.join(valid_dir, '__MACOSX')
                if os.path.exists(macosx_dir):
                    os.system(f'rm -rf {macosx_dir}')
                remove_non_image_files(valid_dir)
        else:
            train_dir = self.train_data
            if self.valid_data:
                valid_dir = self.valid_data
        preprocessor = ImageClassificationPreprocessor(train_data=train_dir, valid_data=valid_dir, token=self.token, project_name=self.project_name, username=self.username, local=self.local)
        return preprocessor.prepare()

@dataclass
class AutoTrainObjectDetectionDataset:
    train_data: str
    token: str
    project_name: str
    username: str
    valid_data: Optional[str] = None
    percent_valid: Optional[float] = None
    local: bool = False

    def __str__(self) -> str:
        info = f'Dataset: {self.project_name} ({self.task})\n'
        info += f'Train data: {self.train_data}\n'
        info += f'Valid data: {self.valid_data}\n'
        return info

    def __post_init__(self):
        self.task = 'image_object_detection'
        if not self.valid_data and self.percent_valid is None:
            self.percent_valid = 0.2
        elif self.valid_data and self.percent_valid is not None:
            raise ValueError('You can only specify one of valid_data or percent_valid')
        elif self.valid_data:
            self.percent_valid = 0.0

    def prepare(self):
        valid_dir = None
        if not isinstance(self.train_data, str):
            cache_dir = os.environ.get('HF_HOME')
            if not cache_dir:
                cache_dir = os.path.join(os.path.expanduser('~'), '.cache', 'huggingface')
            random_uuid = uuid.uuid4()
            train_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
            os.makedirs(train_dir, exist_ok=True)
            self.train_data.seek(0)
            content = self.train_data.read()
            bytes_io = io.BytesIO(content)
            zip_ref = zipfile.ZipFile(bytes_io, 'r')
            zip_ref.extractall(train_dir)
            macosx_dir = os.path.join(train_dir, '__MACOSX')
            if os.path.exists(macosx_dir):
                os.system(f'rm -rf {macosx_dir}')
            remove_non_image_files(train_dir)
            if self.valid_data:
                random_uuid = uuid.uuid4()
                valid_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
                os.makedirs(valid_dir, exist_ok=True)
                self.valid_data.seek(0)
                content = self.valid_data.read()
                bytes_io = io.BytesIO(content)
                zip_ref = zipfile.ZipFile(bytes_io, 'r')
                zip_ref.extractall(valid_dir)
                macosx_dir = os.path.join(valid_dir, '__MACOSX')
                if os.path.exists(macosx_dir):
                    os.system(f'rm -rf {macosx_dir}')
                remove_non_image_files(valid_dir)
        else:
            train_dir = self.train_data
            if self.valid_data:
                valid_dir = self.valid_data
        preprocessor = ObjectDetectionPreprocessor(train_data=train_dir, valid_data=valid_dir, token=self.token, project_name=self.project_name, username=self.username, local=self.local)
        return preprocessor.prepare()

@dataclass
class AutoTrainVLMDataset:
    train_data: str
    token: str
    project_name: str
    username: str
    column_mapping: Dict[str, str]
    valid_data: Optional[str] = None
    percent_valid: Optional[float] = None
    local: bool = False

    def __str__(self) -> str:
        info = f'Dataset: {self.project_name} ({self.task})\n'
        info += f'Train data: {self.train_data}\n'
        info += f'Valid data: {self.valid_data}\n'
        return info

    def __post_init__(self):
        self.task = 'vlm'
        if not self.valid_data and self.percent_valid is None:
            self.percent_valid = 0.2
        elif self.valid_data and self.percent_valid is not None:
            raise ValueError('You can only specify one of valid_data or percent_valid')
        elif self.valid_data:
            self.percent_valid = 0.0

    def prepare(self):
        valid_dir = None
        if not isinstance(self.train_data, str):
            cache_dir = os.environ.get('HF_HOME')
            if not cache_dir:
                cache_dir = os.path.join(os.path.expanduser('~'), '.cache', 'huggingface')
            random_uuid = uuid.uuid4()
            train_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
            os.makedirs(train_dir, exist_ok=True)
            self.train_data.seek(0)
            content = self.train_data.read()
            bytes_io = io.BytesIO(content)
            zip_ref = zipfile.ZipFile(bytes_io, 'r')
            zip_ref.extractall(train_dir)
            macosx_dir = os.path.join(train_dir, '__MACOSX')
            if os.path.exists(macosx_dir):
                os.system(f'rm -rf {macosx_dir}')
            remove_non_image_files(train_dir)
            if self.valid_data:
                random_uuid = uuid.uuid4()
                valid_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
                os.makedirs(valid_dir, exist_ok=True)
                self.valid_data.seek(0)
                content = self.valid_data.read()
                bytes_io = io.BytesIO(content)
                zip_ref = zipfile.ZipFile(bytes_io, 'r')
                zip_ref.extractall(valid_dir)
                macosx_dir = os.path.join(valid_dir, '__MACOSX')
                if os.path.exists(macosx_dir):
                    os.system(f'rm -rf {macosx_dir}')
                remove_non_image_files(valid_dir)
        else:
            train_dir = self.train_data
            if self.valid_data:
                valid_dir = self.valid_data
        preprocessor = VLMPreprocessor(train_data=train_dir, valid_data=valid_dir, token=self.token, project_name=self.project_name, username=self.username, local=self.local, column_mapping=self.column_mapping)
        return preprocessor.prepare()

@dataclass
class AutoTrainImageRegressionDataset:
    train_data: str
    token: str
    project_name: str
    username: str
    valid_data: Optional[str] = None
    percent_valid: Optional[float] = None
    local: bool = False

    def __str__(self) -> str:
        info = f'Dataset: {self.project_name} ({self.task})\n'
        info += f'Train data: {self.train_data}\n'
        info += f'Valid data: {self.valid_data}\n'
        return info

    def __post_init__(self):
        self.task = 'image_single_column_regression'
        if not self.valid_data and self.percent_valid is None:
            self.percent_valid = 0.2
        elif self.valid_data and self.percent_valid is not None:
            raise ValueError('You can only specify one of valid_data or percent_valid')
        elif self.valid_data:
            self.percent_valid = 0.0

    def prepare(self):
        valid_dir = None
        if not isinstance(self.train_data, str):
            cache_dir = os.environ.get('HF_HOME')
            if not cache_dir:
                cache_dir = os.path.join(os.path.expanduser('~'), '.cache', 'huggingface')
            random_uuid = uuid.uuid4()
            train_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
            os.makedirs(train_dir, exist_ok=True)
            self.train_data.seek(0)
            content = self.train_data.read()
            bytes_io = io.BytesIO(content)
            zip_ref = zipfile.ZipFile(bytes_io, 'r')
            zip_ref.extractall(train_dir)
            macosx_dir = os.path.join(train_dir, '__MACOSX')
            if os.path.exists(macosx_dir):
                os.system(f'rm -rf {macosx_dir}')
            remove_non_image_files(train_dir)
            if self.valid_data:
                random_uuid = uuid.uuid4()
                valid_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
                os.makedirs(valid_dir, exist_ok=True)
                self.valid_data.seek(0)
                content = self.valid_data.read()
                bytes_io = io.BytesIO(content)
                zip_ref = zipfile.ZipFile(bytes_io, 'r')
                zip_ref.extractall(valid_dir)
                macosx_dir = os.path.join(valid_dir, '__MACOSX')
                if os.path.exists(macosx_dir):
                    os.system(f'rm -rf {macosx_dir}')
                remove_non_image_files(valid_dir)
        else:
            train_dir = self.train_data
            if self.valid_data:
                valid_dir = self.valid_data
        preprocessor = ImageRegressionPreprocessor(train_data=train_dir, valid_data=valid_dir, token=self.token, project_name=self.project_name, username=self.username, local=self.local)
        return preprocessor.prepare()

@dataclass
class AutoTrainDataset:
    train_data: List[str]
    task: str
    token: str
    project_name: str
    username: Optional[str] = None
    column_mapping: Optional[Dict[str, str]] = None
    valid_data: Optional[List[str]] = None
    percent_valid: Optional[float] = None
    convert_to_class_label: Optional[bool] = False
    local: bool = False
    ext: Optional[str] = 'csv'

    def __str__(self) -> str:
        info = f'Dataset: {self.project_name} ({self.task})\n'
        info += f'Train data: {self.train_data}\n'
        info += f'Valid data: {self.valid_data}\n'
        info += f'Column mapping: {self.column_mapping}\n'
        return info

    def __post_init__(self):
        if self.valid_data is None:
            self.valid_data = []
        if not self.valid_data and self.percent_valid is None:
            self.percent_valid = 0.2
        elif self.valid_data and self.percent_valid is not None:
            raise ValueError('You can only specify one of valid_data or percent_valid')
        elif self.valid_data:
            self.percent_valid = 0.0
        (self.train_df, self.valid_df) = self._preprocess_data()

    def _preprocess_data(self):
        train_df = []
        for file in self.train_data:
            if isinstance(file, pd.DataFrame):
                train_df.append(file)
            elif self.ext == 'jsonl':
                train_df.append(pd.read_json(file, lines=True))
            else:
                train_df.append(pd.read_csv(file))
        if len(train_df) > 1:
            train_df = pd.concat(train_df)
        else:
            train_df = train_df[0]
        valid_df = None
        if len(self.valid_data) > 0:
            valid_df = []
            for file in self.valid_data:
                if isinstance(file, pd.DataFrame):
                    valid_df.append(file)
                elif self.ext == 'jsonl':
                    valid_df.append(pd.read_json(file, lines=True))
                else:
                    valid_df.append(pd.read_csv(file))
            if len(valid_df) > 1:
                valid_df = pd.concat(valid_df)
            else:
                valid_df = valid_df[0]
        return (train_df, valid_df)

    @property
    def num_samples(self):
        return len(self.train_df) + len(self.valid_df) if self.valid_df is not None else len(self.train_df)

    def prepare(self):
        if self.task == 'text_binary_classification':
            text_column = self.column_mapping['text']
            label_column = self.column_mapping['label']
            preprocessor = TextBinaryClassificationPreprocessor(train_data=self.train_df, text_column=text_column, label_column=label_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, convert_to_class_label=self.convert_to_class_label, local=self.local)
            return preprocessor.prepare()
        elif self.task == 'text_multi_class_classification':
            text_column = self.column_mapping['text']
            label_column = self.column_mapping['label']
            preprocessor = TextMultiClassClassificationPreprocessor(train_data=self.train_df, text_column=text_column, label_column=label_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, convert_to_class_label=self.convert_to_class_label, local=self.local)
            return preprocessor.prepare()
        elif self.task == 'text_token_classification':
            text_column = self.column_mapping['text']
            label_column = self.column_mapping['label']
            preprocessor = TextTokenClassificationPreprocessor(train_data=self.train_df, text_column=text_column, label_column=label_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local, convert_to_class_label=self.convert_to_class_label)
            return preprocessor.prepare()
        elif self.task == 'text_single_column_regression':
            text_column = self.column_mapping['text']
            label_column = self.column_mapping['label']
            preprocessor = TextSingleColumnRegressionPreprocessor(train_data=self.train_df, text_column=text_column, label_column=label_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local)
            return preprocessor.prepare()
        elif self.task == 'seq2seq':
            text_column = self.column_mapping['text']
            label_column = self.column_mapping['label']
            preprocessor = Seq2SeqPreprocessor(train_data=self.train_df, text_column=text_column, label_column=label_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local)
            return preprocessor.prepare()
        elif self.task == 'lm_training':
            text_column = self.column_mapping['text']
            prompt_column = self.column_mapping.get('prompt')
            rejected_text_column = self.column_mapping.get('rejected_text')
            preprocessor = LLMPreprocessor(train_data=self.train_df, text_column=text_column, prompt_column=prompt_column, rejected_text_column=rejected_text_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local)
            return preprocessor.prepare()
        elif self.task == 'sentence_transformers':
            sentence1_column = self.column_mapping['sentence1']
            sentence2_column = self.column_mapping['sentence2']
            sentence3_column = self.column_mapping.get('sentence3')
            target_column = self.column_mapping.get('target')
            preprocessor = SentenceTransformersPreprocessor(train_data=self.train_df, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local, sentence1_column=sentence1_column, sentence2_column=sentence2_column, sentence3_column=sentence3_column, target_column=target_column, convert_to_class_label=self.convert_to_class_label)
            return preprocessor.prepare()
        elif self.task == 'text_extractive_question_answering':
            text_column = self.column_mapping['text']
            question_column = self.column_mapping['question']
            answer_column = self.column_mapping['answer']
            preprocessor = TextExtractiveQuestionAnsweringPreprocessor(train_data=self.train_df, text_column=text_column, question_column=question_column, answer_column=answer_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local)
            return preprocessor.prepare()
        elif self.task == 'tabular_binary_classification':
            id_column = self.column_mapping['id']
            label_column = self.column_mapping['label'][0]
            if len(id_column.strip()) == 0:
                id_column = None
            preprocessor = TabularBinaryClassificationPreprocessor(train_data=self.train_df, id_column=id_column, label_column=label_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local)
            return preprocessor.prepare()
        elif self.task == 'tabular_multi_class_classification':
            id_column = self.column_mapping['id']
            label_column = self.column_mapping['label'][0]
            if len(id_column.strip()) == 0:
                id_column = None
            preprocessor = TabularMultiClassClassificationPreprocessor(train_data=self.train_df, id_column=id_column, label_column=label_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local)
            return preprocessor.prepare()
        elif self.task == 'tabular_single_column_regression':
            id_column = self.column_mapping['id']
            label_column = self.column_mapping['label'][0]
            if len(id_column.strip()) == 0:
                id_column = None
            preprocessor = TabularSingleColumnRegressionPreprocessor(train_data=self.train_df, id_column=id_column, label_column=label_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local)
            return preprocessor.prepare()
        elif self.task == 'tabular_multi_column_regression':
            id_column = self.column_mapping['id']
            label_column = self.column_mapping['label']
            if len(id_column.strip()) == 0:
                id_column = None
            preprocessor = TabularMultiColumnRegressionPreprocessor(train_data=self.train_df, id_column=id_column, label_column=label_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local)
            return preprocessor.prepare()
        elif self.task == 'tabular_multi_label_classification':
            id_column = self.column_mapping['id']
            label_column = self.column_mapping['label']
            if len(id_column.strip()) == 0:
                id_column = None
            preprocessor = TabularMultiLabelClassificationPreprocessor(train_data=self.train_df, id_column=id_column, label_column=label_column, username=self.username, project_name=self.project_name, valid_data=self.valid_df, test_size=self.percent_valid, token=self.token, seed=42, local=self.local)
            return preprocessor.prepare()
        else:
            raise ValueError(f'Task {self.task} not supported')

# File: autotrain-advanced-main/src/autotrain/help.py
autotrain_user_info = '\n<p>Please choose the user or organization who is creating the AutoTrain Project.</p>\n<p>In case of non-free tier, this user or organization will be billed.</p>\n'
project_name_info = 'A unique name for the AutoTrain Project.\nThis name will be used to identify the project in the AutoTrain dashboard.'
column_mapping_info = '\n<p>Column Mapping is used to map the columns in the dataset to the columns in the AutoTrain Project.</p>\n<p>For example, if your dataset has a column named "input" and you want to use it as the input for the model,\nyou can map it to the "text" column in the AutoTrain Project.</p>\n<p>Similarly, if your dataset has a column named "label" and you want to use it as the label for the model,\nyou can map it to the "target" column in the AutoTrain Project.</p>\n<p>Column mapping keys are AutoTrain Project column names and values are your dataset column names.</p>\n<p>For tabular datasets, you can map multiple targets to the "label" column. This will enable multi-label task.\nThe column names must be a comma separated list.</p>\n<p>For other tasks, mappings are one-to-one.</p>\n<p>Note: column names are case sensitive.</p>\n'
base_model_info = '\n<p>Base Model is the model that will be used for fine-tuning.</p>\n<p>For example, if you are training a text classification model, you can choose a base model like "bert-base-uncased".</p>\n<p>For a list of available models, please see <a href="https://huggingface.co/models" target="_blank">HuggingFace Model Hub</a>.</p>\n<p>Note: not all models listed here are going to be compatible with\nyour data and parameters. You should select a model that is compatible with your task, data and parameters.</p>\nDont see your favorite model? You can also use a custom model by providing the model name in an environment variable: AUTOTRAIN_CUSTOM_MODELS.\nFor example, go to settings and add a new environment variable with the key AUTOTRAIN_CUSTOM_MODELS and value as the model name (e.g. google/gemma-7b)\n'
hardware_info = '\n\n<p>Hardware is the machine that will be used for training.</p>\n<p>Please choose a hardware that is compatible with your task, data and parameters.</p>\n'
task_info = '\n<p>Task is the type of model you want to train.</p>\n<p>Please choose a task that is compatible with your data and parameters.</p>\n<p>For example, if you are training a text classification model, you can choose "Text Classification" task.</p>\n'
APP_IMAGE_CLASSIFICATION_DATA_HELP = 'The data for the Image Classification task should be in the following format:\n- The data should be in a zip file.\n- The zip file should contain multiple folders (the classes), each folder should contain images of a single class.\n- The name of the folder should be the name of the class.\n- The images must be jpeg, jpg or png.\n- There should be at least 5 images per class.\n- There should not be any other files in the zip file.\n- There should not be any other folders inside the zip folder.\n'
APP_LM_TRAINING_TYPE = 'There are two types of Language Model Training:\n- generic\n- chat\n\nIn the generic mode, you provide a CSV with a text column which has already been formatted by you for training a language model.\nIn the chat mode, you provide a CSV with two or three text columns: prompt, context (optional) and response.\nContext column can be empty for samples if not needed. You can also have a "prompt start" column. If provided, "prompt start" will be prepended before the prompt column.\n\nPlease see [this](https://huggingface.co/datasets/tatsu-lab/alpaca) dataset which has both formats in the same dataset.\n'

def get_app_help(element_id):
    if element_id == 'autotrain_user_info':
        return autotrain_user_info
    elif element_id == 'project_name_info':
        return project_name_info
    elif element_id == 'column_mapping_info':
        return column_mapping_info
    elif element_id == 'base_model_info':
        return base_model_info
    elif element_id == 'hardware_info':
        return hardware_info
    elif element_id == 'task_info':
        return task_info
    else:
        return 'No help available for this element.'

# File: autotrain-advanced-main/src/autotrain/logging.py
import sys
from dataclasses import dataclass
from accelerate.state import PartialState
from loguru import logger

@dataclass
class Logger:

    def __post_init__(self):
        self.log_format = '<level>{level: <8}</level> | <green>{time:YYYY-MM-DD HH:mm:ss}</green> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>'
        self.logger = logger
        self.setup_logger()

    def _should_log(self, record):
        return PartialState().is_main_process

    def setup_logger(self):
        self.logger.remove()
        self.logger.add(sys.stdout, format=self.log_format, filter=lambda x: self._should_log(x))

    def get_logger(self):
        return self.logger

# File: autotrain-advanced-main/src/autotrain/parser.py
import os
from dataclasses import dataclass
import requests
import yaml
from autotrain import logger
from autotrain.cli.utils import dreambooth_munge_data, ext_qa_munge_data, img_clf_munge_data, img_obj_detect_munge_data, img_reg_munge_data, llm_munge_data, sent_transformers_munge_data, seq2seq_munge_data, tabular_munge_data, text_clf_munge_data, text_reg_munge_data, token_clf_munge_data, vlm_munge_data
from autotrain.project import AutoTrainProject
from autotrain.tasks import TASKS
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams
from autotrain.trainers.extractive_question_answering.params import ExtractiveQuestionAnsweringParams
from autotrain.trainers.image_classification.params import ImageClassificationParams
from autotrain.trainers.image_regression.params import ImageRegressionParams
from autotrain.trainers.object_detection.params import ObjectDetectionParams
from autotrain.trainers.sent_transformers.params import SentenceTransformersParams
from autotrain.trainers.seq2seq.params import Seq2SeqParams
from autotrain.trainers.tabular.params import TabularParams
from autotrain.trainers.text_classification.params import TextClassificationParams
from autotrain.trainers.text_regression.params import TextRegressionParams
from autotrain.trainers.token_classification.params import TokenClassificationParams
from autotrain.trainers.vlm.params import VLMTrainingParams

@dataclass
class AutoTrainConfigParser:
    config_path: str

    def __post_init__(self):
        if self.config_path.startswith('http'):
            response = requests.get(self.config_path)
            if response.status_code == 200:
                self.config = yaml.safe_load(response.content)
            else:
                raise ValueError('Failed to retrieve YAML file.')
        else:
            with open(self.config_path, 'r') as f:
                self.config = yaml.safe_load(f)
        self.task_param_map = {'lm_training': LLMTrainingParams, 'dreambooth': DreamBoothTrainingParams, 'image_binary_classification': ImageClassificationParams, 'image_multi_class_classification': ImageClassificationParams, 'image_object_detection': ObjectDetectionParams, 'seq2seq': Seq2SeqParams, 'tabular': TabularParams, 'text_binary_classification': TextClassificationParams, 'text_multi_class_classification': TextClassificationParams, 'text_single_column_regression': TextRegressionParams, 'text_token_classification': TokenClassificationParams, 'sentence_transformers': SentenceTransformersParams, 'image_single_column_regression': ImageRegressionParams, 'vlm': VLMTrainingParams, 'text_extractive_question_answering': ExtractiveQuestionAnsweringParams}
        self.munge_data_map = {'lm_training': llm_munge_data, 'dreambooth': dreambooth_munge_data, 'tabular': tabular_munge_data, 'seq2seq': seq2seq_munge_data, 'image_multi_class_classification': img_clf_munge_data, 'image_object_detection': img_obj_detect_munge_data, 'text_multi_class_classification': text_clf_munge_data, 'text_token_classification': token_clf_munge_data, 'text_single_column_regression': text_reg_munge_data, 'sentence_transformers': sent_transformers_munge_data, 'image_single_column_regression': img_reg_munge_data, 'vlm': vlm_munge_data, 'text_extractive_question_answering': ext_qa_munge_data}
        self.task_aliases = {'llm': 'lm_training', 'llm-sft': 'lm_training', 'llm-orpo': 'lm_training', 'llm-generic': 'lm_training', 'llm-dpo': 'lm_training', 'llm-reward': 'lm_training', 'dreambooth': 'dreambooth', 'image_binary_classification': 'image_multi_class_classification', 'image-binary-classification': 'image_multi_class_classification', 'image_classification': 'image_multi_class_classification', 'image-classification': 'image_multi_class_classification', 'seq2seq': 'seq2seq', 'tabular': 'tabular', 'text_binary_classification': 'text_multi_class_classification', 'text-binary-classification': 'text_multi_class_classification', 'text_classification': 'text_multi_class_classification', 'text-classification': 'text_multi_class_classification', 'text_single_column_regression': 'text_single_column_regression', 'text-single-column-regression': 'text_single_column_regression', 'text_regression': 'text_single_column_regression', 'text-regression': 'text_single_column_regression', 'token_classification': 'text_token_classification', 'token-classification': 'text_token_classification', 'image_object_detection': 'image_object_detection', 'image-object-detection': 'image_object_detection', 'object_detection': 'image_object_detection', 'object-detection': 'image_object_detection', 'st': 'sentence_transformers', 'st:pair': 'sentence_transformers', 'st:pair_class': 'sentence_transformers', 'st:pair_score': 'sentence_transformers', 'st:triplet': 'sentence_transformers', 'st:qa': 'sentence_transformers', 'sentence-transformers:pair': 'sentence_transformers', 'sentence-transformers:pair_class': 'sentence_transformers', 'sentence-transformers:pair_score': 'sentence_transformers', 'sentence-transformers:triplet': 'sentence_transformers', 'sentence-transformers:qa': 'sentence_transformers', 'image_single_column_regression': 'image_single_column_regression', 'image-single-column-regression': 'image_single_column_regression', 'image_regression': 'image_single_column_regression', 'image-regression': 'image_single_column_regression', 'image-scoring': 'image_single_column_regression', 'vlm:captioning': 'vlm', 'vlm:vqa': 'vlm', 'extractive_question_answering': 'text_extractive_question_answering', 'ext_qa': 'text_extractive_question_answering', 'ext-qa': 'text_extractive_question_answering', 'extractive-qa': 'text_extractive_question_answering'}
        task = self.config.get('task')
        self.task = self.task_aliases.get(task, task)
        if self.task is None:
            raise ValueError('Task is required in the configuration file')
        if self.task not in TASKS:
            raise ValueError(f'Task `{self.task}` is not supported')
        self.backend = self.config.get('backend')
        if self.backend is None:
            raise ValueError('Backend is required in the configuration file')
        logger.info(f'Running task: {self.task}')
        logger.info(f'Using backend: {self.backend}')
        self.parsed_config = self._parse_config()

    def _parse_config(self):
        params = {'model': self.config['base_model'], 'project_name': self.config['project_name']}
        if self.task == 'dreambooth':
            params['image_path'] = self.config['data']['path']
            params['prompt'] = self.config['data']['prompt']
        else:
            params['data_path'] = self.config['data']['path']
        if self.task == 'lm_training':
            params['chat_template'] = self.config['data']['chat_template']
            if '-' in self.config['task']:
                params['trainer'] = self.config['task'].split('-')[1]
                if params['trainer'] == 'generic':
                    params['trainer'] = 'default'
                if params['trainer'] not in ['sft', 'orpo', 'dpo', 'reward', 'default']:
                    raise ValueError('Invalid LLM training task')
        if self.task == 'sentence_transformers':
            params['trainer'] = self.config['task'].split(':')[1]
        if self.task == 'vlm':
            params['trainer'] = self.config['task'].split(':')[1]
        if self.task != 'dreambooth':
            for (k, v) in self.config['data']['column_mapping'].items():
                params[k] = v
            params['train_split'] = self.config['data']['train_split']
            params['valid_split'] = self.config['data']['valid_split']
            params['log'] = self.config['log']
        if 'hub' in self.config:
            params['username'] = self.config['hub']['username']
            params['token'] = self.config['hub']['token']
            params['push_to_hub'] = self.config['hub']['push_to_hub']
        else:
            params['username'] = None
            params['token'] = None
            params['push_to_hub'] = False
        if params['username']:
            if params['username'].startswith('${'):
                params['username'] = os.environ.get(params['username'][2:-1])
        if params['token']:
            if params['token'].startswith('${'):
                params['token'] = os.environ.get(params['token'][2:-1])
        other_params = self.config.get('params')
        if other_params:
            params.update(other_params)
        return params

    def run(self):
        _params = self.task_param_map[self.task](**self.parsed_config)
        logger.info(_params)
        _munge_fn = self.munge_data_map[self.task]
        _munge_fn(_params, local=self.backend.startswith('local'))
        project = AutoTrainProject(params=_params, backend=self.backend)
        job_id = project.create()
        logger.info(f'Job ID: {job_id}')

# File: autotrain-advanced-main/src/autotrain/preprocessor/dreambooth.py
import io
import json
import os
from dataclasses import dataclass
from typing import Any, List
from huggingface_hub import HfApi, create_repo
from autotrain import logger

@dataclass
class DreamboothPreprocessor:
    concept_images: List[Any]
    concept_name: str
    username: str
    project_name: str
    token: str
    local: bool

    def __post_init__(self):
        self.repo_name = f'{self.username}/autotrain-data-{self.project_name}'
        if not self.local:
            try:
                create_repo(repo_id=self.repo_name, repo_type='dataset', token=self.token, private=True, exist_ok=False)
            except Exception:
                logger.error('Error creating repo')
                raise ValueError('Error creating repo')

    def _upload_concept_images(self, file, api):
        logger.info(f'Uploading {file} to concept1')
        if isinstance(file, str):
            path_in_repo = f"concept1/{file.split('/')[-1]}"
        else:
            path_in_repo = f"concept1/{file.filename.split('/')[-1]}"
        api.upload_file(path_or_fileobj=file if isinstance(file, str) else file.file.read(), path_in_repo=path_in_repo, repo_id=self.repo_name, repo_type='dataset', token=self.token)

    def _upload_concept_prompts(self, api):
        _prompts = {}
        _prompts['concept1'] = self.concept_name
        prompts = json.dumps(_prompts)
        prompts = prompts.encode('utf-8')
        prompts = io.BytesIO(prompts)
        api.upload_file(path_or_fileobj=prompts, path_in_repo='prompts.json', repo_id=self.repo_name, repo_type='dataset', token=self.token)

    def _save_concept_images(self, file):
        logger.info('Saving concept images')
        logger.info(file)
        if isinstance(file, str):
            _file = file
            path = f"{self.project_name}/autotrain-data/concept1/{_file.split('/')[-1]}"
        else:
            _file = file.file.read()
            path = f"{self.project_name}/autotrain-data/concept1/{file.filename.split('/')[-1]}"
        os.makedirs(os.path.dirname(path), exist_ok=True)
        if isinstance(file, str):
            with open(_file, 'rb') as f:
                with open(path, 'wb') as f2:
                    f2.write(f.read())
        else:
            with open(path, 'wb') as f:
                f.write(_file)

    def _save_concept_prompts(self):
        _prompts = {}
        _prompts['concept1'] = self.concept_name
        path = f'{self.project_name}/autotrain-data/prompts.json'
        with open(path, 'w', encoding='utf-8') as f:
            json.dump(_prompts, f)

    def prepare(self):
        api = HfApi(token=self.token)
        for _file in self.concept_images:
            if self.local:
                self._save_concept_images(_file)
            else:
                self._upload_concept_images(_file, api)
        if self.local:
            self._save_concept_prompts()
        else:
            self._upload_concept_prompts(api)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

# File: autotrain-advanced-main/src/autotrain/preprocessor/tabular.py
from dataclasses import dataclass
from typing import List, Optional
import pandas as pd
from datasets import Dataset, DatasetDict
from sklearn.model_selection import train_test_split
RESERVED_COLUMNS = ['autotrain_id', 'autotrain_label']

@dataclass
class TabularBinaryClassificationPreprocessor:
    train_data: pd.DataFrame
    label_column: str
    username: str
    project_name: str
    token: str
    id_column: Optional[str] = None
    valid_data: Optional[pd.DataFrame] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    local: Optional[bool] = False

    def __post_init__(self):
        if self.id_column is not None:
            if self.id_column not in self.train_data.columns:
                raise ValueError(f'{self.id_column} not in train data')
        if self.label_column not in self.train_data.columns:
            raise ValueError(f'{self.label_column} not in train data')
        if self.valid_data is not None:
            if self.id_column is not None:
                if self.id_column not in self.valid_data.columns:
                    raise ValueError(f'{self.id_column} not in valid data')
            if self.label_column not in self.valid_data.columns:
                raise ValueError(f'{self.label_column} not in valid data')
        for column in RESERVED_COLUMNS:
            if column in self.train_data.columns:
                raise ValueError(f'{column} is a reserved column name')
            if self.valid_data is not None:
                if column in self.valid_data.columns:
                    raise ValueError(f'{column} is a reserved column name')

    def split(self):
        if self.valid_data is not None:
            return (self.train_data, self.valid_data)
        else:
            (train_df, valid_df) = train_test_split(self.train_data, test_size=self.test_size, random_state=self.seed, stratify=self.train_data[self.label_column])
            train_df = train_df.reset_index(drop=True)
            valid_df = valid_df.reset_index(drop=True)
            return (train_df, valid_df)

    def prepare_columns(self, train_df, valid_df):
        train_df.loc[:, 'autotrain_id'] = train_df[self.id_column] if self.id_column else list(range(len(train_df)))
        train_df.loc[:, 'autotrain_label'] = train_df[self.label_column]
        valid_df.loc[:, 'autotrain_id'] = valid_df[self.id_column] if self.id_column else list(range(len(valid_df)))
        valid_df.loc[:, 'autotrain_label'] = valid_df[self.label_column]
        drop_cols = [self.id_column, self.label_column] if self.id_column else [self.label_column]
        train_df = train_df.drop(columns=drop_cols)
        valid_df = valid_df.drop(columns=drop_cols)
        return (train_df, valid_df)

    def prepare(self):
        (train_df, valid_df) = self.split()
        (train_df, valid_df) = self.prepare_columns(train_df, valid_df)
        train_df = Dataset.from_pandas(train_df)
        valid_df = Dataset.from_pandas(valid_df)
        if self.local:
            dataset = DatasetDict({'train': train_df, 'validation': valid_df})
            dataset.save_to_disk(f'{self.project_name}/autotrain-data')
        else:
            train_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='train', private=True, token=self.token)
            valid_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='validation', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

class TabularMultiClassClassificationPreprocessor(TabularBinaryClassificationPreprocessor):
    pass

class TabularSingleColumnRegressionPreprocessor(TabularBinaryClassificationPreprocessor):

    def split(self):
        if self.valid_data is not None:
            return (self.train_data, self.valid_data)
        else:
            (train_df, valid_df) = train_test_split(self.train_data, test_size=self.test_size, random_state=self.seed)
            train_df = train_df.reset_index(drop=True)
            valid_df = valid_df.reset_index(drop=True)
            return (train_df, valid_df)

@dataclass
class TabularMultiLabelClassificationPreprocessor:
    train_data: pd.DataFrame
    label_column: List[str]
    username: str
    project_name: str
    id_column: Optional[str] = None
    valid_data: Optional[pd.DataFrame] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    token: Optional[str] = None
    local: Optional[bool] = False

    def __post_init__(self):
        if self.id_column is not None:
            if self.id_column not in self.train_data.columns:
                raise ValueError(f'{self.id_column} not in train data')
        for label in self.label_column:
            if label not in self.train_data.columns:
                raise ValueError(f'{label} not in train data')
        if self.valid_data is not None:
            if self.id_column is not None:
                if self.id_column not in self.valid_data.columns:
                    raise ValueError(f'{self.id_column} not in valid data')
            for label in self.label_column:
                if label not in self.valid_data.columns:
                    raise ValueError(f'{label} not in valid data')
        for column in RESERVED_COLUMNS:
            if column in self.train_data.columns:
                raise ValueError(f'{column} is a reserved column name')
            if self.valid_data is not None:
                if column in self.valid_data.columns:
                    raise ValueError(f'{column} is a reserved column name')

    def split(self):
        if self.valid_data is not None:
            return (self.train_data, self.valid_data)
        else:
            (train_df, valid_df) = train_test_split(self.train_data, test_size=self.test_size, random_state=self.seed, stratify=self.train_data[self.label_column])
            train_df = train_df.reset_index(drop=True)
            valid_df = valid_df.reset_index(drop=True)
            return (train_df, valid_df)

    def prepare_columns(self, train_df, valid_df):
        train_df.loc[:, 'autotrain_id'] = train_df[self.id_column] if self.id_column else list(range(len(train_df)))
        for label in range(len(self.label_column)):
            train_df.loc[:, f'autotrain_label_{label}'] = train_df[self.label_column[label]]
        valid_df.loc[:, 'autotrain_id'] = valid_df[self.id_column] if self.id_column else list(range(len(valid_df)))
        for label in range(len(self.label_column)):
            valid_df.loc[:, f'autotrain_label_{label}'] = valid_df[self.label_column[label]]
        drop_cols = [self.id_column] + self.label_column if self.id_column else self.label_column
        train_df = train_df.drop(columns=drop_cols)
        valid_df = valid_df.drop(columns=drop_cols)
        return (train_df, valid_df)

    def prepare(self):
        (train_df, valid_df) = self.split()
        (train_df, valid_df) = self.prepare_columns(train_df, valid_df)
        train_df = Dataset.from_pandas(train_df)
        valid_df = Dataset.from_pandas(valid_df)
        if self.local:
            dataset = DatasetDict({'train': train_df, 'validation': valid_df})
            dataset.save_to_disk(f'{self.project_name}/autotrain-data')
        else:
            train_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='train', private=True, token=self.token)
            valid_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='validation', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

class TabularMultiColumnRegressionPreprocessor(TabularMultiLabelClassificationPreprocessor):
    pass

# File: autotrain-advanced-main/src/autotrain/preprocessor/text.py
import ast
from dataclasses import dataclass
from typing import Optional
import pandas as pd
from datasets import ClassLabel, Dataset, DatasetDict, Sequence
from sklearn.model_selection import train_test_split
from autotrain import logger
RESERVED_COLUMNS = ['autotrain_text', 'autotrain_label', 'autotrain_question', 'autotrain_answer']
LLM_RESERVED_COLUMNS = ['autotrain_prompt', 'autotrain_context', 'autotrain_rejected_text', 'autotrain_prompt_start']

@dataclass
class TextBinaryClassificationPreprocessor:
    train_data: pd.DataFrame
    text_column: str
    label_column: str
    username: str
    project_name: str
    token: str
    valid_data: Optional[pd.DataFrame] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    convert_to_class_label: Optional[bool] = False
    local: Optional[bool] = False

    def __post_init__(self):
        if self.text_column not in self.train_data.columns:
            raise ValueError(f'{self.text_column} not in train data')
        if self.label_column not in self.train_data.columns:
            raise ValueError(f'{self.label_column} not in train data')
        if self.valid_data is not None:
            if self.text_column not in self.valid_data.columns:
                raise ValueError(f'{self.text_column} not in valid data')
            if self.label_column not in self.valid_data.columns:
                raise ValueError(f'{self.label_column} not in valid data')
        for column in RESERVED_COLUMNS:
            if column in self.train_data.columns:
                raise ValueError(f'{column} is a reserved column name')
            if self.valid_data is not None:
                if column in self.valid_data.columns:
                    raise ValueError(f'{column} is a reserved column name')

    def split(self):
        if self.valid_data is not None:
            return (self.train_data, self.valid_data)
        else:
            (train_df, valid_df) = train_test_split(self.train_data, test_size=self.test_size, random_state=self.seed, stratify=self.train_data[self.label_column])
            train_df = train_df.reset_index(drop=True)
            valid_df = valid_df.reset_index(drop=True)
            return (train_df, valid_df)

    def prepare_columns(self, train_df, valid_df):
        train_df.loc[:, 'autotrain_text'] = train_df[self.text_column]
        train_df.loc[:, 'autotrain_label'] = train_df[self.label_column]
        valid_df.loc[:, 'autotrain_text'] = valid_df[self.text_column]
        valid_df.loc[:, 'autotrain_label'] = valid_df[self.label_column]
        train_df = train_df.drop(columns=[self.text_column, self.label_column])
        valid_df = valid_df.drop(columns=[self.text_column, self.label_column])
        return (train_df, valid_df)

    def prepare(self):
        (train_df, valid_df) = self.split()
        (train_df, valid_df) = self.prepare_columns(train_df, valid_df)
        train_df.loc[:, 'autotrain_label'] = train_df['autotrain_label'].astype(str)
        valid_df.loc[:, 'autotrain_label'] = valid_df['autotrain_label'].astype(str)
        label_names = sorted(set(train_df['autotrain_label'].unique().tolist()))
        train_df = Dataset.from_pandas(train_df)
        valid_df = Dataset.from_pandas(valid_df)
        if self.convert_to_class_label:
            train_df = train_df.cast_column('autotrain_label', ClassLabel(names=label_names))
            valid_df = valid_df.cast_column('autotrain_label', ClassLabel(names=label_names))
        if self.local:
            dataset = DatasetDict({'train': train_df, 'validation': valid_df})
            dataset.save_to_disk(f'{self.project_name}/autotrain-data')
        else:
            train_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='train', private=True, token=self.token)
            valid_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='validation', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

class TextMultiClassClassificationPreprocessor(TextBinaryClassificationPreprocessor):
    pass

class TextSingleColumnRegressionPreprocessor(TextBinaryClassificationPreprocessor):

    def split(self):
        if self.valid_data is not None:
            return (self.train_data, self.valid_data)
        else:
            (train_df, valid_df) = train_test_split(self.train_data, test_size=self.test_size, random_state=self.seed)
            train_df = train_df.reset_index(drop=True)
            valid_df = valid_df.reset_index(drop=True)
            return (train_df, valid_df)

    def prepare(self):
        (train_df, valid_df) = self.split()
        (train_df, valid_df) = self.prepare_columns(train_df, valid_df)
        train_df = Dataset.from_pandas(train_df)
        valid_df = Dataset.from_pandas(valid_df)
        if self.local:
            dataset = DatasetDict({'train': train_df, 'validation': valid_df})
            dataset.save_to_disk(f'{self.project_name}/autotrain-data')
        else:
            train_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='train', private=True, token=self.token)
            valid_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='validation', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

class TextTokenClassificationPreprocessor(TextBinaryClassificationPreprocessor):

    def split(self):
        if self.valid_data is not None:
            return (self.train_data, self.valid_data)
        else:
            (train_df, valid_df) = train_test_split(self.train_data, test_size=self.test_size, random_state=self.seed)
            train_df = train_df.reset_index(drop=True)
            valid_df = valid_df.reset_index(drop=True)
            return (train_df, valid_df)

    def prepare(self):
        (train_df, valid_df) = self.split()
        (train_df, valid_df) = self.prepare_columns(train_df, valid_df)
        try:
            train_df.loc[:, 'autotrain_text'] = train_df['autotrain_text'].apply(lambda x: ast.literal_eval(x))
            valid_df.loc[:, 'autotrain_text'] = valid_df['autotrain_text'].apply(lambda x: ast.literal_eval(x))
        except ValueError:
            logger.warning("Unable to do ast.literal_eval on train_df['autotrain_text']")
            logger.warning('assuming autotrain_text is already a list')
        try:
            train_df.loc[:, 'autotrain_label'] = train_df['autotrain_label'].apply(lambda x: ast.literal_eval(x))
            valid_df.loc[:, 'autotrain_label'] = valid_df['autotrain_label'].apply(lambda x: ast.literal_eval(x))
        except ValueError:
            logger.warning("Unable to do ast.literal_eval on train_df['autotrain_label']")
            logger.warning('assuming autotrain_label is already a list')
        label_names_train = sorted(set(train_df['autotrain_label'].explode().unique().tolist()))
        label_names_valid = sorted(set(valid_df['autotrain_label'].explode().unique().tolist()))
        label_names = sorted(set(label_names_train + label_names_valid))
        train_df = Dataset.from_pandas(train_df)
        valid_df = Dataset.from_pandas(valid_df)
        if self.convert_to_class_label:
            train_df = train_df.cast_column('autotrain_label', Sequence(ClassLabel(names=label_names)))
            valid_df = valid_df.cast_column('autotrain_label', Sequence(ClassLabel(names=label_names)))
        if self.local:
            dataset = DatasetDict({'train': train_df, 'validation': valid_df})
            dataset.save_to_disk(f'{self.project_name}/autotrain-data')
        else:
            train_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='train', private=True, token=self.token)
            valid_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='validation', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

@dataclass
class LLMPreprocessor:
    train_data: pd.DataFrame
    username: str
    project_name: str
    token: str
    valid_data: Optional[pd.DataFrame] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    text_column: Optional[str] = None
    prompt_column: Optional[str] = None
    rejected_text_column: Optional[str] = None
    local: Optional[bool] = False

    def __post_init__(self):
        if self.text_column is None:
            raise ValueError('text_column must be provided')
        if self.prompt_column is not None and self.prompt_column not in self.train_data.columns:
            self.prompt_column = None
        if self.rejected_text_column is not None and self.rejected_text_column not in self.train_data.columns:
            self.rejected_text_column = None
        for column in RESERVED_COLUMNS + LLM_RESERVED_COLUMNS:
            if column in self.train_data.columns:
                raise ValueError(f'{column} is a reserved column name')
            if self.valid_data is not None:
                if column in self.valid_data.columns:
                    raise ValueError(f'{column} is a reserved column name')

    def split(self):
        if self.valid_data is not None:
            return (self.train_data, self.valid_data)
        return (self.train_data, self.train_data)

    def prepare_columns(self, train_df, valid_df):
        drop_cols = [self.text_column]
        train_df.loc[:, 'autotrain_text'] = train_df[self.text_column]
        valid_df.loc[:, 'autotrain_text'] = valid_df[self.text_column]
        if self.prompt_column is not None:
            drop_cols.append(self.prompt_column)
            train_df.loc[:, 'autotrain_prompt'] = train_df[self.prompt_column]
            valid_df.loc[:, 'autotrain_prompt'] = valid_df[self.prompt_column]
        if self.rejected_text_column is not None:
            drop_cols.append(self.rejected_text_column)
            train_df.loc[:, 'autotrain_rejected_text'] = train_df[self.rejected_text_column]
            valid_df.loc[:, 'autotrain_rejected_text'] = valid_df[self.rejected_text_column]
        train_df = train_df.drop(columns=drop_cols)
        valid_df = valid_df.drop(columns=drop_cols)
        return (train_df, valid_df)

    def prepare(self):
        (train_df, valid_df) = self.split()
        (train_df, valid_df) = self.prepare_columns(train_df, valid_df)
        train_df = Dataset.from_pandas(train_df)
        valid_df = Dataset.from_pandas(valid_df)
        if self.local:
            dataset = DatasetDict({'train': train_df, 'validation': valid_df})
            dataset.save_to_disk(f'{self.project_name}/autotrain-data')
        else:
            train_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='train', private=True, token=self.token)
            valid_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='validation', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

@dataclass
class Seq2SeqPreprocessor:
    train_data: pd.DataFrame
    text_column: str
    label_column: str
    username: str
    project_name: str
    token: str
    valid_data: Optional[pd.DataFrame] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    local: Optional[bool] = False

    def __post_init__(self):
        if self.text_column not in self.train_data.columns:
            raise ValueError(f'{self.text_column} not in train data')
        if self.label_column not in self.train_data.columns:
            raise ValueError(f'{self.label_column} not in train data')
        if self.valid_data is not None:
            if self.text_column not in self.valid_data.columns:
                raise ValueError(f'{self.text_column} not in valid data')
            if self.label_column not in self.valid_data.columns:
                raise ValueError(f'{self.label_column} not in valid data')
        for column in RESERVED_COLUMNS:
            if column in self.train_data.columns:
                raise ValueError(f'{column} is a reserved column name')
            if self.valid_data is not None:
                if column in self.valid_data.columns:
                    raise ValueError(f'{column} is a reserved column name')

    def split(self):
        if self.valid_data is not None:
            return (self.train_data, self.valid_data)
        else:
            (train_df, valid_df) = train_test_split(self.train_data, test_size=self.test_size, random_state=self.seed)
            train_df = train_df.reset_index(drop=True)
            valid_df = valid_df.reset_index(drop=True)
            return (train_df, valid_df)

    def prepare_columns(self, train_df, valid_df):
        train_df.loc[:, 'autotrain_text'] = train_df[self.text_column]
        train_df.loc[:, 'autotrain_label'] = train_df[self.label_column]
        valid_df.loc[:, 'autotrain_text'] = valid_df[self.text_column]
        valid_df.loc[:, 'autotrain_label'] = valid_df[self.label_column]
        train_df = train_df.drop(columns=[self.text_column, self.label_column])
        valid_df = valid_df.drop(columns=[self.text_column, self.label_column])
        return (train_df, valid_df)

    def prepare(self):
        (train_df, valid_df) = self.split()
        (train_df, valid_df) = self.prepare_columns(train_df, valid_df)
        train_df = Dataset.from_pandas(train_df)
        valid_df = Dataset.from_pandas(valid_df)
        if self.local:
            dataset = DatasetDict({'train': train_df, 'validation': valid_df})
            dataset.save_to_disk(f'{self.project_name}/autotrain-data')
        else:
            train_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='train', private=True, token=self.token)
            valid_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='validation', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

@dataclass
class SentenceTransformersPreprocessor:
    train_data: pd.DataFrame
    username: str
    project_name: str
    token: str
    valid_data: Optional[pd.DataFrame] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    local: Optional[bool] = False
    sentence1_column: Optional[str] = 'sentence1'
    sentence2_column: Optional[str] = 'sentence2'
    sentence3_column: Optional[str] = 'sentence3'
    target_column: Optional[str] = 'target'
    convert_to_class_label: Optional[bool] = False

    def __post_init__(self):
        for column in RESERVED_COLUMNS + LLM_RESERVED_COLUMNS:
            if column in self.train_data.columns:
                raise ValueError(f'{column} is a reserved column name')
            if self.valid_data is not None:
                if column in self.valid_data.columns:
                    raise ValueError(f'{column} is a reserved column name')

    def split(self):
        if self.valid_data is not None:
            return (self.train_data, self.valid_data)
        else:
            (train_df, valid_df) = train_test_split(self.train_data, test_size=self.test_size, random_state=self.seed)
            train_df = train_df.reset_index(drop=True)
            valid_df = valid_df.reset_index(drop=True)
            return (train_df, valid_df)

    def prepare_columns(self, train_df, valid_df):
        train_df.loc[:, 'autotrain_sentence1'] = train_df[self.sentence1_column]
        train_df.loc[:, 'autotrain_sentence2'] = train_df[self.sentence2_column]
        valid_df.loc[:, 'autotrain_sentence1'] = valid_df[self.sentence1_column]
        valid_df.loc[:, 'autotrain_sentence2'] = valid_df[self.sentence2_column]
        keep_cols = ['autotrain_sentence1', 'autotrain_sentence2']
        if self.sentence3_column is not None:
            train_df.loc[:, 'autotrain_sentence3'] = train_df[self.sentence3_column]
            valid_df.loc[:, 'autotrain_sentence3'] = valid_df[self.sentence3_column]
            keep_cols.append('autotrain_sentence3')
        if self.target_column is not None:
            train_df.loc[:, 'autotrain_target'] = train_df[self.target_column]
            valid_df.loc[:, 'autotrain_target'] = valid_df[self.target_column]
            keep_cols.append('autotrain_target')
        train_df = train_df[keep_cols]
        valid_df = valid_df[keep_cols]
        return (train_df, valid_df)

    def prepare(self):
        (train_df, valid_df) = self.split()
        (train_df, valid_df) = self.prepare_columns(train_df, valid_df)
        if self.convert_to_class_label:
            label_names = sorted(set(train_df['autotrain_target'].unique().tolist()))
        train_df = Dataset.from_pandas(train_df)
        valid_df = Dataset.from_pandas(valid_df)
        if self.convert_to_class_label:
            train_df = train_df.cast_column('autotrain_target', ClassLabel(names=label_names))
            valid_df = valid_df.cast_column('autotrain_target', ClassLabel(names=label_names))
        if self.local:
            dataset = DatasetDict({'train': train_df, 'validation': valid_df})
            dataset.save_to_disk(f'{self.project_name}/autotrain-data')
        else:
            train_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='train', private=True, token=self.token)
            valid_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='validation', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

@dataclass
class TextExtractiveQuestionAnsweringPreprocessor:
    train_data: pd.DataFrame
    text_column: str
    question_column: str
    answer_column: str
    username: str
    project_name: str
    token: str
    valid_data: Optional[pd.DataFrame] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    local: Optional[bool] = False

    def __post_init__(self):
        if self.text_column not in self.train_data.columns:
            raise ValueError(f'{self.text_column} not in train data')
        if self.question_column not in self.train_data.columns:
            raise ValueError(f'{self.question_column} not in train data')
        if self.answer_column not in self.train_data.columns:
            raise ValueError(f'{self.answer_column} not in train data')
        if self.valid_data is not None:
            if self.text_column not in self.valid_data.columns:
                raise ValueError(f'{self.text_column} not in valid data')
            if self.question_column not in self.valid_data.columns:
                raise ValueError(f'{self.question_column} not in valid data')
            if self.answer_column not in self.valid_data.columns:
                raise ValueError(f'{self.answer_column} not in valid data')
        for column in RESERVED_COLUMNS:
            if column in self.train_data.columns:
                raise ValueError(f'{column} is a reserved column name')
            if self.valid_data is not None:
                if column in self.valid_data.columns:
                    raise ValueError(f'{column} is a reserved column name')
        try:
            self.train_data.loc[:, self.answer_column] = self.train_data[self.answer_column].apply(lambda x: ast.literal_eval(x))
        except ValueError:
            logger.warning('Unable to do ast.literal_eval on train_data[answer_column]')
            logger.warning('assuming answer_column is already a dict')
        if self.valid_data is not None:
            try:
                self.valid_data.loc[:, self.answer_column] = self.valid_data[self.answer_column].apply(lambda x: ast.literal_eval(x))
            except ValueError:
                logger.warning('Unable to do ast.literal_eval on valid_data[answer_column]')
                logger.warning('assuming answer_column is already a dict')

    def split(self):
        if self.valid_data is not None:
            return (self.train_data, self.valid_data)
        else:
            (train_df, valid_df) = train_test_split(self.train_data, test_size=self.test_size, random_state=self.seed)
            train_df = train_df.reset_index(drop=True)
            valid_df = valid_df.reset_index(drop=True)
            return (train_df, valid_df)

    def prepare_columns(self, train_df, valid_df):
        train_df.loc[:, 'autotrain_text'] = train_df[self.text_column]
        train_df.loc[:, 'autotrain_question'] = train_df[self.question_column]
        train_df.loc[:, 'autotrain_answer'] = train_df[self.answer_column]
        valid_df.loc[:, 'autotrain_text'] = valid_df[self.text_column]
        valid_df.loc[:, 'autotrain_question'] = valid_df[self.question_column]
        valid_df.loc[:, 'autotrain_answer'] = valid_df[self.answer_column]
        train_df = train_df.drop(columns=[x for x in train_df.columns if x not in ['autotrain_text', 'autotrain_question', 'autotrain_answer']])
        valid_df = valid_df.drop(columns=[x for x in valid_df.columns if x not in ['autotrain_text', 'autotrain_question', 'autotrain_answer']])
        return (train_df, valid_df)

    def prepare(self):
        (train_df, valid_df) = self.split()
        (train_df, valid_df) = self.prepare_columns(train_df, valid_df)
        train_df = Dataset.from_pandas(train_df)
        valid_df = Dataset.from_pandas(valid_df)
        if self.local:
            dataset = DatasetDict({'train': train_df, 'validation': valid_df})
            dataset.save_to_disk(f'{self.project_name}/autotrain-data')
        else:
            train_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='train', private=True, token=self.token)
            valid_df.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', split='validation', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

# File: autotrain-advanced-main/src/autotrain/preprocessor/vision.py
import os
import shutil
import uuid
from dataclasses import dataclass
from typing import Optional
import pandas as pd
from datasets import ClassLabel, Features, Image, Sequence, Value, load_dataset
from sklearn.model_selection import train_test_split
ALLOWED_EXTENSIONS = ('jpeg', 'png', 'jpg', 'JPG', 'JPEG', 'PNG')

@dataclass
class ImageClassificationPreprocessor:
    train_data: str
    username: str
    project_name: str
    token: str
    valid_data: Optional[str] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    local: Optional[bool] = False

    def __post_init__(self):
        if not os.path.exists(self.train_data):
            raise ValueError(f'{self.train_data} does not exist.')
        subfolders = [f.path for f in os.scandir(self.train_data) if f.is_dir()]
        if len(subfolders) < 2:
            raise ValueError(f'{self.train_data} should contain at least 2 subfolders.')
        for subfolder in subfolders:
            image_files = [f for f in os.listdir(subfolder) if f.endswith(ALLOWED_EXTENSIONS)]
            if len(image_files) < 5:
                raise ValueError(f'{subfolder} should contain at least 5 jpeg, png or jpg files.')
            if len(image_files) != len(os.listdir(subfolder)):
                raise ValueError(f'{subfolder} should not contain any other files except image files.')
            subfolders_in_subfolder = [f.path for f in os.scandir(subfolder) if f.is_dir()]
            if len(subfolders_in_subfolder) > 0:
                raise ValueError(f'{subfolder} should not contain any subfolders.')
        if self.valid_data:
            if not os.path.exists(self.valid_data):
                raise ValueError(f'{self.valid_data} does not exist.')
            subfolders = [f.path for f in os.scandir(self.valid_data) if f.is_dir()]
            train_subfolders = set((os.path.basename(f.path) for f in os.scandir(self.train_data) if f.is_dir()))
            valid_subfolders = set((os.path.basename(f.path) for f in os.scandir(self.valid_data) if f.is_dir()))
            if train_subfolders != valid_subfolders:
                raise ValueError(f'{self.valid_data} should have the same subfolders as {self.train_data}.')
            if len(subfolders) < 2:
                raise ValueError(f'{self.valid_data} should contain at least 2 subfolders.')
            for subfolder in subfolders:
                image_files = [f for f in os.listdir(subfolder) if f.endswith(ALLOWED_EXTENSIONS)]
                if len(image_files) < 5:
                    raise ValueError(f'{subfolder} should contain at least 5 jpeg, png or jpg files.')
                if len(image_files) != len(os.listdir(subfolder)):
                    raise ValueError(f'{subfolder} should not contain any other files except image files.')
                subfolders_in_subfolder = [f.path for f in os.scandir(subfolder) if f.is_dir()]
                if len(subfolders_in_subfolder) > 0:
                    raise ValueError(f'{subfolder} should not contain any subfolders.')

    def split(self, df):
        (train_df, valid_df) = train_test_split(df, test_size=self.test_size, random_state=self.seed, stratify=df['subfolder'])
        train_df = train_df.reset_index(drop=True)
        valid_df = valid_df.reset_index(drop=True)
        return (train_df, valid_df)

    def prepare(self):
        random_uuid = uuid.uuid4()
        cache_dir = os.environ.get('HF_HOME')
        if not cache_dir:
            cache_dir = os.path.join(os.path.expanduser('~'), '.cache', 'huggingface')
        data_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
        if self.valid_data:
            shutil.copytree(self.train_data, os.path.join(data_dir, 'train'))
            shutil.copytree(self.valid_data, os.path.join(data_dir, 'validation'))
            dataset = load_dataset('imagefolder', data_dir=data_dir)
            dataset = dataset.rename_columns({'image': 'autotrain_image', 'label': 'autotrain_label'})
            if self.local:
                dataset.save_to_disk(f'{self.project_name}/autotrain-data')
            else:
                dataset.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', private=True, token=self.token)
        else:
            subfolders = [f.path for f in os.scandir(self.train_data) if f.is_dir()]
            image_filenames = []
            subfolder_names = []
            for subfolder in subfolders:
                for filename in os.listdir(subfolder):
                    if filename.endswith(('jpeg', 'png', 'jpg')):
                        image_filenames.append(filename)
                        subfolder_names.append(os.path.basename(subfolder))
            df = pd.DataFrame({'image_filename': image_filenames, 'subfolder': subfolder_names})
            (train_df, valid_df) = self.split(df)
            for row in train_df.itertuples():
                os.makedirs(os.path.join(data_dir, 'train', row.subfolder), exist_ok=True)
                shutil.copy(os.path.join(self.train_data, row.subfolder, row.image_filename), os.path.join(data_dir, 'train', row.subfolder, row.image_filename))
            for row in valid_df.itertuples():
                os.makedirs(os.path.join(data_dir, 'validation', row.subfolder), exist_ok=True)
                shutil.copy(os.path.join(self.train_data, row.subfolder, row.image_filename), os.path.join(data_dir, 'validation', row.subfolder, row.image_filename))
            dataset = load_dataset('imagefolder', data_dir=data_dir)
            dataset = dataset.rename_columns({'image': 'autotrain_image', 'label': 'autotrain_label'})
            if self.local:
                dataset.save_to_disk(f'{self.project_name}/autotrain-data')
            else:
                dataset.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

@dataclass
class ObjectDetectionPreprocessor:
    train_data: str
    username: str
    project_name: str
    token: str
    valid_data: Optional[str] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    local: Optional[bool] = False

    @staticmethod
    def _process_metadata(data_path):
        metadata = pd.read_json(os.path.join(data_path, 'metadata.jsonl'), lines=True)
        if 'file_name' not in metadata.columns or 'objects' not in metadata.columns:
            raise ValueError(f"{data_path}/metadata.jsonl should contain 'file_name' and 'objects' columns.")
        metadata = metadata[['file_name', 'objects']]
        categories = []
        for (_, row) in metadata.iterrows():
            obj = row['objects']
            if 'bbox' not in obj or 'category' not in obj:
                raise ValueError(f"{data_path}/metadata.jsonl should contain 'bbox' and 'category' keys in 'objects'.")
            obj = {k: obj[k] for k in ['bbox', 'category']}
            categories.extend(obj['category'])
        categories = set(categories)
        return (metadata, categories)

    def __post_init__(self):
        if not os.path.exists(self.train_data):
            raise ValueError(f'{self.train_data} does not exist.')
        train_image_files = [f for f in os.listdir(self.train_data) if f.endswith(ALLOWED_EXTENSIONS)]
        if len(train_image_files) < 5:
            raise ValueError(f'{self.train_data} should contain at least 5 jpeg, png or jpg files.')
        if 'metadata.jsonl' not in os.listdir(self.train_data):
            raise ValueError(f'{self.train_data} should contain a metadata.jsonl file.')
        if self.valid_data:
            if not os.path.exists(self.valid_data):
                raise ValueError(f'{self.valid_data} does not exist.')
            valid_image_files = [f for f in os.listdir(self.valid_data) if f.endswith(ALLOWED_EXTENSIONS)]
            if len(valid_image_files) < 5:
                raise ValueError(f'{self.valid_data} should contain at least 5 jpeg, png or jpg files.')
            if 'metadata.jsonl' not in os.listdir(self.valid_data):
                raise ValueError(f'{self.valid_data} should contain a metadata.jsonl file.')

    def split(self, df):
        (train_df, valid_df) = train_test_split(df, test_size=self.test_size, random_state=self.seed)
        train_df = train_df.reset_index(drop=True)
        valid_df = valid_df.reset_index(drop=True)
        return (train_df, valid_df)

    def prepare(self):
        random_uuid = uuid.uuid4()
        cache_dir = os.environ.get('HF_HOME')
        if not cache_dir:
            cache_dir = os.path.join(os.path.expanduser('~'), '.cache', 'huggingface')
        data_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
        if self.valid_data:
            shutil.copytree(self.train_data, os.path.join(data_dir, 'train'))
            shutil.copytree(self.valid_data, os.path.join(data_dir, 'validation'))
            (train_metadata, train_categories) = self._process_metadata(os.path.join(data_dir, 'train'))
            (valid_metadata, valid_categories) = self._process_metadata(os.path.join(data_dir, 'validation'))
            train_metadata.to_json(os.path.join(data_dir, 'train', 'metadata.jsonl'), orient='records', lines=True)
            valid_metadata.to_json(os.path.join(data_dir, 'validation', 'metadata.jsonl'), orient='records', lines=True)
            all_categories = train_categories.union(valid_categories)
            features = Features({'image': Image(), 'objects': Sequence({'bbox': Sequence(Value('float32'), length=4), 'category': ClassLabel(names=list(all_categories))})})
            dataset = load_dataset('imagefolder', data_dir=data_dir, features=features)
            dataset = dataset.rename_columns({'image': 'autotrain_image', 'objects': 'autotrain_objects'})
            if self.local:
                dataset.save_to_disk(f'{self.project_name}/autotrain-data')
            else:
                dataset.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', private=True, token=self.token)
        else:
            metadata = pd.read_json(os.path.join(self.train_data, 'metadata.jsonl'), lines=True)
            (train_df, valid_df) = self.split(metadata)
            os.makedirs(os.path.join(data_dir, 'train'), exist_ok=True)
            os.makedirs(os.path.join(data_dir, 'validation'), exist_ok=True)
            for row in train_df.iterrows():
                shutil.copy(os.path.join(self.train_data, row[1]['file_name']), os.path.join(data_dir, 'train', row[1]['file_name']))
            for row in valid_df.iterrows():
                shutil.copy(os.path.join(self.train_data, row[1]['file_name']), os.path.join(data_dir, 'validation', row[1]['file_name']))
            train_df.to_json(os.path.join(data_dir, 'train', 'metadata.jsonl'), orient='records', lines=True)
            valid_df.to_json(os.path.join(data_dir, 'validation', 'metadata.jsonl'), orient='records', lines=True)
            (train_metadata, train_categories) = self._process_metadata(os.path.join(data_dir, 'train'))
            (valid_metadata, valid_categories) = self._process_metadata(os.path.join(data_dir, 'validation'))
            train_metadata.to_json(os.path.join(data_dir, 'train', 'metadata.jsonl'), orient='records', lines=True)
            valid_metadata.to_json(os.path.join(data_dir, 'validation', 'metadata.jsonl'), orient='records', lines=True)
            all_categories = train_categories.union(valid_categories)
            features = Features({'image': Image(), 'objects': Sequence({'bbox': Sequence(Value('float32'), length=4), 'category': ClassLabel(names=list(all_categories))})})
            dataset = load_dataset('imagefolder', data_dir=data_dir, features=features)
            dataset = dataset.rename_columns({'image': 'autotrain_image', 'objects': 'autotrain_objects'})
            if self.local:
                dataset.save_to_disk(f'{self.project_name}/autotrain-data')
            else:
                dataset.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

@dataclass
class ImageRegressionPreprocessor:
    train_data: str
    username: str
    project_name: str
    token: str
    valid_data: Optional[str] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    local: Optional[bool] = False

    @staticmethod
    def _process_metadata(data_path):
        metadata = pd.read_json(os.path.join(data_path, 'metadata.jsonl'), lines=True)
        if 'file_name' not in metadata.columns or 'target' not in metadata.columns:
            raise ValueError(f"{data_path}/metadata.jsonl should contain 'file_name' and 'target' columns.")
        metadata = metadata[['file_name', 'target']]
        return metadata

    def __post_init__(self):
        if not os.path.exists(self.train_data):
            raise ValueError(f'{self.train_data} does not exist.')
        train_image_files = [f for f in os.listdir(self.train_data) if f.endswith(ALLOWED_EXTENSIONS)]
        if len(train_image_files) < 5:
            raise ValueError(f'{self.train_data} should contain at least 5 jpeg, png or jpg files.')
        if 'metadata.jsonl' not in os.listdir(self.train_data):
            raise ValueError(f'{self.train_data} should contain a metadata.jsonl file.')
        if self.valid_data:
            if not os.path.exists(self.valid_data):
                raise ValueError(f'{self.valid_data} does not exist.')
            valid_image_files = [f for f in os.listdir(self.valid_data) if f.endswith(ALLOWED_EXTENSIONS)]
            if len(valid_image_files) < 5:
                raise ValueError(f'{self.valid_data} should contain at least 5 jpeg, png or jpg files.')
            if 'metadata.jsonl' not in os.listdir(self.valid_data):
                raise ValueError(f'{self.valid_data} should contain a metadata.jsonl file.')

    def split(self, df):
        (train_df, valid_df) = train_test_split(df, test_size=self.test_size, random_state=self.seed)
        train_df = train_df.reset_index(drop=True)
        valid_df = valid_df.reset_index(drop=True)
        return (train_df, valid_df)

    def prepare(self):
        random_uuid = uuid.uuid4()
        cache_dir = os.environ.get('HF_HOME')
        if not cache_dir:
            cache_dir = os.path.join(os.path.expanduser('~'), '.cache', 'huggingface')
        data_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
        if self.valid_data:
            shutil.copytree(self.train_data, os.path.join(data_dir, 'train'))
            shutil.copytree(self.valid_data, os.path.join(data_dir, 'validation'))
            train_metadata = self._process_metadata(os.path.join(data_dir, 'train'))
            valid_metadata = self._process_metadata(os.path.join(data_dir, 'validation'))
            train_metadata.to_json(os.path.join(data_dir, 'train', 'metadata.jsonl'), orient='records', lines=True)
            valid_metadata.to_json(os.path.join(data_dir, 'validation', 'metadata.jsonl'), orient='records', lines=True)
            dataset = load_dataset('imagefolder', data_dir=data_dir)
            dataset = dataset.rename_columns({'image': 'autotrain_image', 'target': 'autotrain_label'})
            if self.local:
                dataset.save_to_disk(f'{self.project_name}/autotrain-data')
            else:
                dataset.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', private=True, token=self.token)
        else:
            metadata = pd.read_json(os.path.join(self.train_data, 'metadata.jsonl'), lines=True)
            (train_df, valid_df) = self.split(metadata)
            os.makedirs(os.path.join(data_dir, 'train'), exist_ok=True)
            os.makedirs(os.path.join(data_dir, 'validation'), exist_ok=True)
            for row in train_df.iterrows():
                shutil.copy(os.path.join(self.train_data, row[1]['file_name']), os.path.join(data_dir, 'train', row[1]['file_name']))
            for row in valid_df.iterrows():
                shutil.copy(os.path.join(self.train_data, row[1]['file_name']), os.path.join(data_dir, 'validation', row[1]['file_name']))
            train_df.to_json(os.path.join(data_dir, 'train', 'metadata.jsonl'), orient='records', lines=True)
            valid_df.to_json(os.path.join(data_dir, 'validation', 'metadata.jsonl'), orient='records', lines=True)
            train_metadata = self._process_metadata(os.path.join(data_dir, 'train'))
            valid_metadata = self._process_metadata(os.path.join(data_dir, 'validation'))
            train_metadata.to_json(os.path.join(data_dir, 'train', 'metadata.jsonl'), orient='records', lines=True)
            valid_metadata.to_json(os.path.join(data_dir, 'validation', 'metadata.jsonl'), orient='records', lines=True)
            dataset = load_dataset('imagefolder', data_dir=data_dir)
            dataset = dataset.rename_columns({'image': 'autotrain_image', 'target': 'autotrain_label'})
            if self.local:
                dataset.save_to_disk(f'{self.project_name}/autotrain-data')
            else:
                dataset.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

# File: autotrain-advanced-main/src/autotrain/preprocessor/vlm.py
import os
import shutil
import uuid
from dataclasses import dataclass
from typing import Optional
import pandas as pd
from datasets import Features, Image, Value, load_dataset
from sklearn.model_selection import train_test_split
ALLOWED_EXTENSIONS = ('jpeg', 'png', 'jpg', 'JPG', 'JPEG', 'PNG')

@dataclass
class VLMPreprocessor:
    train_data: str
    username: str
    project_name: str
    token: str
    column_mapping: dict
    valid_data: Optional[str] = None
    test_size: Optional[float] = 0.2
    seed: Optional[int] = 42
    local: Optional[bool] = False

    def _process_metadata(self, data_path):
        metadata = pd.read_json(os.path.join(data_path, 'metadata.jsonl'), lines=True)
        if 'file_name' not in metadata.columns:
            raise ValueError(f"{data_path}/metadata.jsonl should contain 'file_name' column.")
        col_names = list(self.column_mapping.values())
        for col in col_names:
            if col not in metadata.columns:
                raise ValueError(f"{data_path}/metadata.jsonl should contain '{col}' column.")
        return metadata

    def __post_init__(self):
        if not os.path.exists(self.train_data):
            raise ValueError(f'{self.train_data} does not exist.')
        train_image_files = [f for f in os.listdir(self.train_data) if f.endswith(ALLOWED_EXTENSIONS)]
        if len(train_image_files) < 5:
            raise ValueError(f'{self.train_data} should contain at least 5 jpeg, png or jpg files.')
        if 'metadata.jsonl' not in os.listdir(self.train_data):
            raise ValueError(f'{self.train_data} should contain a metadata.jsonl file.')
        if self.valid_data:
            if not os.path.exists(self.valid_data):
                raise ValueError(f'{self.valid_data} does not exist.')
            valid_image_files = [f for f in os.listdir(self.valid_data) if f.endswith(ALLOWED_EXTENSIONS)]
            if len(valid_image_files) < 5:
                raise ValueError(f'{self.valid_data} should contain at least 5 jpeg, png or jpg files.')
            if 'metadata.jsonl' not in os.listdir(self.valid_data):
                raise ValueError(f'{self.valid_data} should contain a metadata.jsonl file.')

    def split(self, df):
        (train_df, valid_df) = train_test_split(df, test_size=self.test_size, random_state=self.seed)
        train_df = train_df.reset_index(drop=True)
        valid_df = valid_df.reset_index(drop=True)
        return (train_df, valid_df)

    def prepare(self):
        random_uuid = uuid.uuid4()
        cache_dir = os.environ.get('HF_HOME')
        if not cache_dir:
            cache_dir = os.path.join(os.path.expanduser('~'), '.cache', 'huggingface')
        data_dir = os.path.join(cache_dir, 'autotrain', str(random_uuid))
        if self.valid_data:
            shutil.copytree(self.train_data, os.path.join(data_dir, 'train'))
            shutil.copytree(self.valid_data, os.path.join(data_dir, 'validation'))
            train_metadata = self._process_metadata(os.path.join(data_dir, 'train'))
            valid_metadata = self._process_metadata(os.path.join(data_dir, 'validation'))
            train_metadata.to_json(os.path.join(data_dir, 'train', 'metadata.jsonl'), orient='records', lines=True)
            valid_metadata.to_json(os.path.join(data_dir, 'validation', 'metadata.jsonl'), orient='records', lines=True)
            features = Features({'image': Image()})
            for (_, col_map) in self.column_mapping.items():
                features[col_map] = Value(dtype='string')
            dataset = load_dataset('imagefolder', data_dir=data_dir, features=features)
            rename_dict = {'image': 'autotrain_image'}
            for (col, col_map) in self.column_mapping.items():
                if col == 'text_column':
                    rename_dict[col_map] = 'autotrain_text'
                elif col == 'prompt_text_column':
                    rename_dict[col_map] = 'autotrain_prompt'
            dataset = dataset.rename_columns(rename_dict)
            if self.local:
                dataset.save_to_disk(f'{self.project_name}/autotrain-data')
            else:
                dataset.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', private=True, token=self.token)
        else:
            metadata = pd.read_json(os.path.join(self.train_data, 'metadata.jsonl'), lines=True)
            (train_df, valid_df) = self.split(metadata)
            os.makedirs(os.path.join(data_dir, 'train'), exist_ok=True)
            os.makedirs(os.path.join(data_dir, 'validation'), exist_ok=True)
            for row in train_df.iterrows():
                shutil.copy(os.path.join(self.train_data, row[1]['file_name']), os.path.join(data_dir, 'train', row[1]['file_name']))
            for row in valid_df.iterrows():
                shutil.copy(os.path.join(self.train_data, row[1]['file_name']), os.path.join(data_dir, 'validation', row[1]['file_name']))
            train_df.to_json(os.path.join(data_dir, 'train', 'metadata.jsonl'), orient='records', lines=True)
            valid_df.to_json(os.path.join(data_dir, 'validation', 'metadata.jsonl'), orient='records', lines=True)
            train_metadata = self._process_metadata(os.path.join(data_dir, 'train'))
            valid_metadata = self._process_metadata(os.path.join(data_dir, 'validation'))
            train_metadata.to_json(os.path.join(data_dir, 'train', 'metadata.jsonl'), orient='records', lines=True)
            valid_metadata.to_json(os.path.join(data_dir, 'validation', 'metadata.jsonl'), orient='records', lines=True)
            features = Features({'image': Image()})
            for (_, col_map) in self.column_mapping.items():
                features[col_map] = Value(dtype='string')
            dataset = load_dataset('imagefolder', data_dir=data_dir, features=features)
            rename_dict = {'image': 'autotrain_image'}
            for (col, col_map) in self.column_mapping.items():
                if col == 'text_column':
                    rename_dict[col_map] = 'autotrain_text'
                elif col == 'prompt_text_column':
                    rename_dict[col_map] = 'autotrain_prompt'
            dataset = dataset.rename_columns(rename_dict)
            if self.local:
                dataset.save_to_disk(f'{self.project_name}/autotrain-data')
            else:
                dataset.push_to_hub(f'{self.username}/autotrain-data-{self.project_name}', private=True, token=self.token)
        if self.local:
            return f'{self.project_name}/autotrain-data'
        return f'{self.username}/autotrain-data-{self.project_name}'

# File: autotrain-advanced-main/src/autotrain/project.py
""""""
from dataclasses import dataclass
from typing import List, Union
from autotrain.backends.base import AVAILABLE_HARDWARE
from autotrain.backends.endpoints import EndpointsRunner
from autotrain.backends.local import LocalRunner
from autotrain.backends.ngc import NGCRunner
from autotrain.backends.nvcf import NVCFRunner
from autotrain.backends.spaces import SpaceRunner
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams
from autotrain.trainers.image_classification.params import ImageClassificationParams
from autotrain.trainers.image_regression.params import ImageRegressionParams
from autotrain.trainers.object_detection.params import ObjectDetectionParams
from autotrain.trainers.sent_transformers.params import SentenceTransformersParams
from autotrain.trainers.seq2seq.params import Seq2SeqParams
from autotrain.trainers.tabular.params import TabularParams
from autotrain.trainers.text_classification.params import TextClassificationParams
from autotrain.trainers.text_regression.params import TextRegressionParams
from autotrain.trainers.token_classification.params import TokenClassificationParams

@dataclass
class AutoTrainProject:
    params: Union[List[Union[LLMTrainingParams, TextClassificationParams, TabularParams, DreamBoothTrainingParams, Seq2SeqParams, ImageClassificationParams, TextRegressionParams, ObjectDetectionParams, TokenClassificationParams, SentenceTransformersParams, ImageRegressionParams]], LLMTrainingParams, TextClassificationParams, TabularParams, DreamBoothTrainingParams, Seq2SeqParams, ImageClassificationParams, TextRegressionParams, ObjectDetectionParams, TokenClassificationParams, SentenceTransformersParams, ImageRegressionParams]
    backend: str

    def __post_init__(self):
        if self.backend not in AVAILABLE_HARDWARE:
            raise ValueError(f'Invalid backend: {self.backend}')

    def create(self):
        if self.backend.startswith('local'):
            runner = LocalRunner(params=self.params, backend=self.backend)
            return runner.create()
        elif self.backend.startswith('spaces-'):
            runner = SpaceRunner(params=self.params, backend=self.backend)
            return runner.create()
        elif self.backend.startswith('ep-'):
            runner = EndpointsRunner(params=self.params, backend=self.backend)
            return runner.create()
        elif self.backend.startswith('ngc-'):
            runner = NGCRunner(params=self.params, backend=self.backend)
            return runner.create()
        elif self.backend.startswith('nvcf-'):
            runner = NVCFRunner(params=self.params, backend=self.backend)
            return runner.create()
        else:
            raise NotImplementedError

# File: autotrain-advanced-main/src/autotrain/tasks.py
NLP_TASKS = {'text_binary_classification': 1, 'text_multi_class_classification': 2, 'text_token_classification': 4, 'text_extractive_question_answering': 5, 'text_summarization': 8, 'text_single_column_regression': 10, 'speech_recognition': 11, 'natural_language_inference': 22, 'lm_training': 9, 'seq2seq': 28, 'sentence_transformers': 30, 'vlm': 31}
VISION_TASKS = {'image_binary_classification': 17, 'image_multi_class_classification': 18, 'image_single_column_regression': 24, 'image_object_detection': 29, 'dreambooth': 25}
TABULAR_TASKS = {'tabular_binary_classification': 13, 'tabular_multi_class_classification': 14, 'tabular_multi_label_classification': 15, 'tabular_single_column_regression': 16, 'tabular': 26}
TASKS = {**NLP_TASKS, **VISION_TASKS, **TABULAR_TASKS}

# File: autotrain-advanced-main/src/autotrain/tools/convert_to_kohya.py
from diffusers.utils import convert_all_state_dict_to_peft, convert_state_dict_to_kohya
from safetensors.torch import load_file, save_file
from autotrain import logger

def convert_to_kohya(input_path, output_path):
    logger.info(f'Converting Lora state dict from {input_path} to Kohya state dict at {output_path}')
    lora_state_dict = load_file(input_path)
    peft_state_dict = convert_all_state_dict_to_peft(lora_state_dict)
    kohya_state_dict = convert_state_dict_to_kohya(peft_state_dict)
    save_file(kohya_state_dict, output_path)
    logger.info(f'Kohya state dict saved at {output_path}')

# File: autotrain-advanced-main/src/autotrain/tools/merge_adapter.py
import torch
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE

def merge_llm_adapter(base_model_path, adapter_path, token, output_folder=None, pad_to_multiple_of=None, push_to_hub=False):
    if output_folder is None and push_to_hub is False:
        raise ValueError('You must specify either --output_folder or --push_to_hub')
    logger.info('Loading adapter...')
    base_model = AutoModelForCausalLM.from_pretrained(base_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True, trust_remote_code=ALLOW_REMOTE_CODE, token=token)
    tokenizer = AutoTokenizer.from_pretrained(adapter_path, trust_remote_code=ALLOW_REMOTE_CODE, token=token)
    if pad_to_multiple_of:
        base_model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=pad_to_multiple_of)
    else:
        base_model.resize_token_embeddings(len(tokenizer))
    model = PeftModel.from_pretrained(base_model, adapter_path, token=token)
    model = model.merge_and_unload()
    if output_folder is not None:
        logger.info('Saving target model...')
        model.save_pretrained(output_folder)
        tokenizer.save_pretrained(output_folder)
        logger.info(f'Model saved to {output_folder}')
    if push_to_hub:
        logger.info('Pushing model to Hugging Face Hub...')
        model.push_to_hub(adapter_path)
        tokenizer.push_to_hub(adapter_path)
        logger.info(f'Model pushed to Hugging Face Hub as {adapter_path}')

# File: autotrain-advanced-main/src/autotrain/trainers/clm/__main__.py
import argparse
import json
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.trainers.common import monitor

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = LLMTrainingParams(**config)
    if config.trainer == 'default':
        from autotrain.trainers.clm.train_clm_default import train as train_default
        train_default(config)
    elif config.trainer == 'sft':
        from autotrain.trainers.clm.train_clm_sft import train as train_sft
        train_sft(config)
    elif config.trainer == 'reward':
        from autotrain.trainers.clm.train_clm_reward import train as train_reward
        train_reward(config)
    elif config.trainer == 'dpo':
        from autotrain.trainers.clm.train_clm_dpo import train as train_dpo
        train_dpo(config)
    elif config.trainer == 'orpo':
        from autotrain.trainers.clm.train_clm_orpo import train as train_orpo
        train_orpo(config)
    else:
        raise ValueError(f'trainer `{config.trainer}` not supported')
if __name__ == '__main__':
    _args = parse_args()
    training_config = json.load(open(_args.training_config))
    _config = LLMTrainingParams(**training_config)
    train(_config)

# File: autotrain-advanced-main/src/autotrain/trainers/clm/callbacks.py
import os
import torch
from peft import set_peft_model_state_dict
from transformers import TrainerCallback, TrainerControl, TrainerState, TrainingArguments
from transformers.trainer_utils import PREFIX_CHECKPOINT_DIR

class SavePeftModelCallback(TrainerCallback):

    def on_save(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
        checkpoint_folder = os.path.join(args.output_dir, f'{PREFIX_CHECKPOINT_DIR}-{state.global_step}')
        kwargs['model'].save_pretrained(checkpoint_folder)
        pytorch_model_path = os.path.join(checkpoint_folder, 'pytorch_model.bin')
        torch.save({}, pytorch_model_path)
        return control

class LoadBestPeftModelCallback(TrainerCallback):

    def on_train_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
        print(f'Loading best peft model from {state.best_model_checkpoint} (score: {state.best_metric}).')
        best_model_path = os.path.join(state.best_model_checkpoint, 'adapter_model.bin')
        adapters_weights = torch.load(best_model_path)
        model = kwargs['model']
        set_peft_model_state_dict(model, adapters_weights)
        return control

class SaveDeepSpeedPeftModelCallback(TrainerCallback):

    def __init__(self, trainer, save_steps=500):
        self.trainer = trainer
        self.save_steps = save_steps

    def on_step_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
        if (state.global_step + 1) % self.save_steps == 0:
            self.trainer.accelerator.wait_for_everyone()
            state_dict = self.trainer.accelerator.get_state_dict(self.trainer.deepspeed)
            unwrapped_model = self.trainer.accelerator.unwrap_model(self.trainer.deepspeed)
            if self.trainer.accelerator.is_main_process:
                unwrapped_model.save_pretrained(args.output_dir, state_dict=state_dict)
            self.trainer.accelerator.wait_for_everyone()
        return control

# File: autotrain-advanced-main/src/autotrain/trainers/clm/params.py
from typing import List, Optional, Union
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class LLMTrainingParams(AutoTrainParams):
    model: str = Field('gpt2', title='Model name')
    project_name: str = Field('project-name', title='Output directory')
    data_path: str = Field('data', title='Data path')
    train_split: str = Field('train', title='Train data config')
    valid_split: Optional[str] = Field(None, title='Validation data config')
    add_eos_token: bool = Field(True, title='Add EOS token')
    block_size: Union[int, List[int]] = Field(-1, title='Block size')
    model_max_length: int = Field(2048, title='Model max length')
    padding: Optional[str] = Field('right', title='Padding side')
    trainer: str = Field('default', title='Trainer type')
    use_flash_attention_2: bool = Field(False, title='Use flash attention 2')
    log: str = Field('none', title='Logging using experiment tracking')
    disable_gradient_checkpointing: bool = Field(False, title='Gradient checkpointing')
    logging_steps: int = Field(-1, title='Logging steps')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    save_total_limit: int = Field(1, title='Save total limit')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    lr: float = Field(3e-05, title='Learning rate')
    epochs: int = Field(1, title='Number of training epochs')
    batch_size: int = Field(2, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(4, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    seed: int = Field(42, title='Seed')
    chat_template: Optional[str] = Field(None, title='Chat template, one of: None, zephyr, chatml or tokenizer')
    quantization: Optional[str] = Field('int4', title='int4, int8, or None')
    target_modules: Optional[str] = Field('all-linear', title='Target modules')
    merge_adapter: bool = Field(False, title='Merge adapter')
    peft: bool = Field(False, title='Use PEFT')
    lora_r: int = Field(16, title='Lora r')
    lora_alpha: int = Field(32, title='Lora alpha')
    lora_dropout: float = Field(0.05, title='Lora dropout')
    model_ref: Optional[str] = Field(None, title='Reference, for DPO trainer')
    dpo_beta: float = Field(0.1, title='Beta for DPO trainer')
    max_prompt_length: int = Field(128, title='Prompt length')
    max_completion_length: Optional[int] = Field(None, title='Completion length')
    prompt_text_column: Optional[str] = Field(None, title='Prompt text column')
    text_column: str = Field('text', title='Text column')
    rejected_text_column: Optional[str] = Field(None, title='Rejected text column')
    push_to_hub: bool = Field(False, title='Push to hub')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    token: Optional[str] = Field(None, title='Huggingface token')
    unsloth: bool = Field(False, title='Use unsloth')

# File: autotrain-advanced-main/src/autotrain/trainers/clm/train_clm_default.py
from functools import partial
import torch
from datasets import Dataset
from peft.tuners.lora import LoraLayer
from transformers import Trainer, TrainingArguments, default_data_collator
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.clm import utils
from autotrain.trainers.clm.params import LLMTrainingParams

def process_data(data, tokenizer, config):
    data = data.to_pandas()
    data = data.fillna('')
    data = data[[config.text_column]]
    if config.add_eos_token:
        data[config.text_column] = data[config.text_column] + tokenizer.eos_token
    data = Dataset.from_pandas(data)
    return data

def train(config):
    logger.info('Starting default/generic CLM training...')
    if isinstance(config, dict):
        config = LLMTrainingParams(**config)
    (train_data, valid_data) = utils.process_input_data(config)
    tokenizer = utils.get_tokenizer(config)
    (train_data, valid_data) = utils.process_data_with_chat_template(config, tokenizer, train_data, valid_data)
    train_data = process_data(data=train_data, tokenizer=tokenizer, config=config)
    if config.valid_split is not None:
        valid_data = process_data(data=valid_data, tokenizer=tokenizer, config=config)
    logging_steps = utils.configure_logging_steps(config, train_data, valid_data)
    training_args = utils.configure_training_args(config, logging_steps)
    config = utils.configure_block_size(config, tokenizer)
    args = TrainingArguments(**training_args)
    model = utils.get_model(config, tokenizer)
    tokenize_fn = partial(utils.tokenize, tokenizer=tokenizer, config=config)
    group_texts_fn = partial(utils.group_texts, config=config)
    train_data = train_data.map(tokenize_fn, batched=True, num_proc=1, remove_columns=list(train_data.features), desc='Running tokenizer on train dataset')
    if config.valid_split is not None:
        valid_data = valid_data.map(tokenize_fn, batched=True, num_proc=1, remove_columns=list(valid_data.features), desc='Running tokenizer on validation dataset')
    train_data = train_data.map(group_texts_fn, batched=True, num_proc=4, desc=f'Grouping texts in chunks of {config.block_size}')
    if config.valid_split is not None:
        valid_data = valid_data.map(group_texts_fn, batched=True, num_proc=4, desc=f'Grouping texts in chunks of {config.block_size}')
    logger.info('creating trainer')
    callbacks = utils.get_callbacks(config)
    trainer_args = dict(args=args, model=model, callbacks=callbacks)
    trainer = Trainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data if config.valid_split is not None else None, tokenizer=tokenizer, data_collator=default_data_collator)
    for (name, module) in trainer.model.named_modules():
        if isinstance(module, LoraLayer):
            if config.mixed_precision == 'bf16':
                module = module.to(torch.bfloat16)
        if 'norm' in name:
            module = module.to(torch.float32)
        if any((x in name for x in ['lm_head', 'embed_tokens', 'wte', 'wpe'])):
            if hasattr(module, 'weight'):
                if config.mixed_precision == 'bf16' and module.weight.dtype == torch.float32:
                    module = module.to(torch.bfloat16)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    utils.post_training_steps(config, trainer)

# File: autotrain-advanced-main/src/autotrain/trainers/clm/train_clm_dpo.py
import torch
from peft import LoraConfig
from transformers import AutoConfig, AutoModelForCausalLM, BitsAndBytesConfig, TrainingArguments
from transformers.trainer_callback import PrinterCallback
from trl import DPOTrainer
from autotrain import logger
from autotrain.trainers.clm import utils
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.trainers.common import ALLOW_REMOTE_CODE

def train(config):
    logger.info('Starting DPO training...')
    if isinstance(config, dict):
        config = LLMTrainingParams(**config)
    (train_data, valid_data) = utils.process_input_data(config)
    tokenizer = utils.get_tokenizer(config)
    (train_data, valid_data) = utils.process_data_with_chat_template(config, tokenizer, train_data, valid_data)
    logging_steps = utils.configure_logging_steps(config, train_data, valid_data)
    training_args = utils.configure_training_args(config, logging_steps)
    config = utils.configure_block_size(config, tokenizer)
    args = TrainingArguments(**training_args)
    logger.info('loading model config...')
    model_config = AutoConfig.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, use_cache=config.disable_gradient_checkpointing)
    logger.info('loading model...')
    if config.peft:
        if config.quantization == 'int4':
            bnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type='nf4', bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=False)
        elif config.quantization == 'int8':
            bnb_config = BitsAndBytesConfig(load_in_8bit=True)
        else:
            bnb_config = None
        model = AutoModelForCausalLM.from_pretrained(config.model, config=model_config, token=config.token, quantization_config=bnb_config, trust_remote_code=ALLOW_REMOTE_CODE, use_flash_attention_2=config.use_flash_attention_2)
        logger.info('Using PEFT, model_ref will be set to None')
        model_ref = None
    else:
        model = AutoModelForCausalLM.from_pretrained(config.model, config=model_config, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, use_flash_attention_2=config.use_flash_attention_2)
        if config.model_ref is not None:
            model_ref = AutoModelForCausalLM.from_pretrained(config.model_ref, config=model_config, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, use_flash_attention_2=config.use_flash_attention_2)
        else:
            model_ref = None
    logger.info(f'model dtype: {model.dtype}')
    model.resize_token_embeddings(len(tokenizer))
    if model_ref is not None:
        logger.info(f'model_ref dtype: {model_ref.dtype}')
        model_ref.resize_token_embeddings(len(tokenizer))
    if config.peft:
        peft_config = LoraConfig(r=config.lora_r, lora_alpha=config.lora_alpha, lora_dropout=config.lora_dropout, bias='none', task_type='CAUSAL_LM', target_modules=utils.get_target_modules(config))
    logger.info('creating trainer')
    callbacks = utils.get_callbacks(config)
    trainer_args = dict(args=args, model=model, callbacks=callbacks)
    trainer = DPOTrainer(**trainer_args, ref_model=model_ref, beta=config.dpo_beta, train_dataset=train_data, eval_dataset=valid_data if config.valid_split is not None else None, tokenizer=tokenizer, max_length=config.block_size, max_prompt_length=config.max_prompt_length, max_target_length=config.max_completion_length, peft_config=peft_config if config.peft else None)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    utils.post_training_steps(config, trainer)

# File: autotrain-advanced-main/src/autotrain/trainers/clm/train_clm_orpo.py
from peft import LoraConfig
from transformers.trainer_callback import PrinterCallback
from trl import ORPOConfig, ORPOTrainer
from autotrain import logger
from autotrain.trainers.clm import utils
from autotrain.trainers.clm.params import LLMTrainingParams

def train(config):
    logger.info('Starting ORPO training...')
    if isinstance(config, dict):
        config = LLMTrainingParams(**config)
    (train_data, valid_data) = utils.process_input_data(config)
    tokenizer = utils.get_tokenizer(config)
    (train_data, valid_data) = utils.process_data_with_chat_template(config, tokenizer, train_data, valid_data)
    logging_steps = utils.configure_logging_steps(config, train_data, valid_data)
    training_args = utils.configure_training_args(config, logging_steps)
    config = utils.configure_block_size(config, tokenizer)
    training_args['max_length'] = config.block_size
    training_args['max_prompt_length'] = config.max_prompt_length
    training_args['max_completion_length'] = config.max_completion_length
    args = ORPOConfig(**training_args)
    model = utils.get_model(config, tokenizer)
    if config.peft:
        peft_config = LoraConfig(r=config.lora_r, lora_alpha=config.lora_alpha, lora_dropout=config.lora_dropout, bias='none', task_type='CAUSAL_LM', target_modules=utils.get_target_modules(config))
    logger.info('creating trainer')
    callbacks = utils.get_callbacks(config)
    trainer_args = dict(args=args, model=model, callbacks=callbacks)
    trainer = ORPOTrainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data if config.valid_split is not None else None, tokenizer=tokenizer, peft_config=peft_config if config.peft else None)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    utils.post_training_steps(config, trainer)

# File: autotrain-advanced-main/src/autotrain/trainers/clm/train_clm_reward.py
from functools import partial
import torch
from peft import LoraConfig
from transformers import AutoConfig, AutoModelForSequenceClassification, BitsAndBytesConfig
from transformers.trainer_callback import PrinterCallback
from trl import RewardConfig, RewardTrainer
from autotrain import logger
from autotrain.trainers.clm import utils
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.trainers.common import ALLOW_REMOTE_CODE

def train(config):
    logger.info('Starting Reward training...')
    if isinstance(config, dict):
        config = LLMTrainingParams(**config)
    (train_data, valid_data) = utils.process_input_data(config)
    tokenizer = utils.get_tokenizer(config)
    (train_data, valid_data) = utils.process_data_with_chat_template(config, tokenizer, train_data, valid_data)
    logging_steps = utils.configure_logging_steps(config, train_data, valid_data)
    training_args = utils.configure_training_args(config, logging_steps)
    config = utils.configure_block_size(config, tokenizer)
    training_args['max_length'] = config.block_size
    args = RewardConfig(**training_args)
    logger.info('loading model config...')
    model_config = AutoConfig.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, use_cache=config.disable_gradient_checkpointing)
    model_config.num_labels = 1
    model_config.pad_token_id = tokenizer.pad_token_id
    model_config.pad_token = tokenizer.pad_token
    logger.info('loading model...')
    if config.peft:
        if config.quantization == 'int4':
            bnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type='nf4', bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=False)
        elif config.quantization == 'int8':
            bnb_config = BitsAndBytesConfig(load_in_8bit=True)
        else:
            bnb_config = None
        model = AutoModelForSequenceClassification.from_pretrained(config.model, config=model_config, token=config.token, quantization_config=bnb_config, trust_remote_code=ALLOW_REMOTE_CODE, use_flash_attention_2=config.use_flash_attention_2)
    else:
        model = AutoModelForSequenceClassification.from_pretrained(config.model, config=model_config, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, use_flash_attention_2=config.use_flash_attention_2)
    logger.info(f'model dtype: {model.dtype}')
    model.resize_token_embeddings(len(tokenizer))
    if config.peft:
        peft_config = LoraConfig(r=config.lora_r, lora_alpha=config.lora_alpha, lora_dropout=config.lora_dropout, bias='none', task_type='SEQ_CLS', target_modules=utils.get_target_modules(config))
    reward_proc = partial(utils.preprocess_reward, tokenizer=tokenizer)
    train_data = train_data.map(reward_proc, batched=True, num_proc=4, desc='Running tokenizer on train dataset')
    train_data = train_data.filter(lambda x: len(x['input_ids_chosen']) <= config.block_size and len(x['input_ids_rejected']) <= config.block_size)
    if config.valid_split is not None:
        valid_data = valid_data.map(reward_proc, batched=True, num_proc=4, desc='Running tokenizer on validation dataset')
        valid_data = valid_data.filter(lambda x: len(x['input_ids_chosen']) <= config.block_size and len(x['input_ids_rejected']) <= config.block_size)
    logger.info('creating trainer')
    callbacks = utils.get_callbacks(config)
    trainer_args = dict(args=args, model=model, callbacks=callbacks)
    trainer = RewardTrainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data if config.valid_split is not None else None, peft_config=peft_config if config.peft else None, tokenizer=tokenizer)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    utils.post_training_steps(config, trainer)

# File: autotrain-advanced-main/src/autotrain/trainers/clm/train_clm_sft.py
from peft import LoraConfig
from transformers.trainer_callback import PrinterCallback
from trl import SFTConfig, SFTTrainer
from autotrain import logger
from autotrain.trainers.clm import utils
from autotrain.trainers.clm.params import LLMTrainingParams

def train(config):
    logger.info('Starting SFT training...')
    if isinstance(config, dict):
        config = LLMTrainingParams(**config)
    (train_data, valid_data) = utils.process_input_data(config)
    tokenizer = utils.get_tokenizer(config)
    (train_data, valid_data) = utils.process_data_with_chat_template(config, tokenizer, train_data, valid_data)
    logging_steps = utils.configure_logging_steps(config, train_data, valid_data)
    training_args = utils.configure_training_args(config, logging_steps)
    config = utils.configure_block_size(config, tokenizer)
    training_args['dataset_text_field'] = config.text_column
    training_args['max_seq_length'] = config.block_size
    training_args['packing'] = True
    args = SFTConfig(**training_args)
    model = utils.get_model(config, tokenizer)
    if config.peft:
        peft_config = LoraConfig(r=config.lora_r, lora_alpha=config.lora_alpha, lora_dropout=config.lora_dropout, bias='none', task_type='CAUSAL_LM', target_modules=utils.get_target_modules(config))
    logger.info('creating trainer')
    callbacks = utils.get_callbacks(config)
    trainer_args = dict(args=args, model=model, callbacks=callbacks)
    trainer = SFTTrainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data if config.valid_split is not None else None, peft_config=peft_config if config.peft else None, tokenizer=tokenizer)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    utils.post_training_steps(config, trainer)

# File: autotrain-advanced-main/src/autotrain/trainers/clm/utils.py
import ast
import gc
import os
from enum import Enum
from itertools import chain
import requests
import torch
from accelerate.state import PartialState
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from peft import LoraConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training
from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from autotrain import is_unsloth_available, logger
from autotrain.trainers.clm.callbacks import LoadBestPeftModelCallback, SavePeftModelCallback
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, pause_space, remove_autotrain_data, save_training_params
DEFAULT_CHAT_TEMPLATE = "{% if not add_generation_prompt is defined %}{% set add_generation_prompt = false %}{% endif %}{% for message in messages %}{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}"
CHATML_CHAT_TEMPLATE = "{% for message in messages %}\n{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% if loop.last and add_generation_prompt %}{{'<|im_start|>assistant\n' }}{% endif %}{% endfor %}"
ZEPHYR_CHAT_TEMPLATE = "{% for message in messages %}\n{% if message['role'] == 'user' %}\n{{ '<|user|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'system' %}\n{{ '<|system|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'assistant' %}\n{{ '<|assistant|>\n'  + message['content'] + eos_token }}\n{% endif %}\n{% if loop.last and add_generation_prompt %}\n{{ '<|assistant|>' }}\n{% endif %}\n{% endfor %}"
IGNORE_INDEX = -100
DEFAULT_PAD_TOKEN = '[PAD]'
DEFAULT_EOS_TOKEN = '</s>'
DEFAULT_BOS_TOKEN = '</s>'
DEFAULT_UNK_TOKEN = '</s>'
TARGET_MODULES = {'Salesforce/codegen25-7b-multi': 'q_proj,k_proj,v_proj,o_proj,down_proj,up_proj,gate_proj'}
MODEL_CARD = '\n---\ntags:\n- autotrain\n- text-generation-inference\n- text-generation{peft}\nlibrary_name: transformers{base_model}\nwidget:\n  - messages:\n      - role: user\n        content: What is your favorite condiment?\nlicense: other{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\nThis model was trained using AutoTrain. For more information, please visit [AutoTrain](https://hf.co/docs/autotrain).\n\n# Usage\n\n```python\n\nfrom transformers import AutoModelForCausalLM, AutoTokenizer\n\nmodel_path = "PATH_TO_THIS_REPO"\n\ntokenizer = AutoTokenizer.from_pretrained(model_path)\nmodel = AutoModelForCausalLM.from_pretrained(\n    model_path,\n    device_map="auto",\n    torch_dtype=\'auto\'\n).eval()\n\n# Prompt content: "hi"\nmessages = [\n    {{"role": "user", "content": "hi"}}\n]\n\ninput_ids = tokenizer.apply_chat_template(conversation=messages, tokenize=True, add_generation_prompt=True, return_tensors=\'pt\')\noutput_ids = model.generate(input_ids.to(\'cuda\'))\nresponse = tokenizer.decode(output_ids[0][input_ids.shape[1]:], skip_special_tokens=True)\n\n# Model response: "Hello! How can I assist you today?"\nprint(response)\n```\n\n'

class ZephyrSpecialTokens(str, Enum):
    USER = '<|user|>'
    ASSISTANT = '<|assistant|>'
    SYSTEM = '<|system|>'
    EOS_TOKEN = '</s>'
    BOS_TOKEN = '<s>'
    PAD_TOKEN = '<pad>'

    @classmethod
    def list(cls):
        return [c.value for c in cls]

class ChatmlSpecialTokens(str, Enum):
    USER = '<|im_start|>user'
    ASSISTANT = '<|im_start|>assistant'
    SYSTEM = '<|im_start|>system'
    EOS_TOKEN = '<|im_end|>'
    BOS_TOKEN = '<s>'
    PAD_TOKEN = '<pad>'

    @classmethod
    def list(cls):
        return [c.value for c in cls]

def preprocess_reward(examples, tokenizer):
    new_examples = {'input_ids_chosen': [], 'attention_mask_chosen': [], 'input_ids_rejected': [], 'attention_mask_rejected': []}
    for (chosen, rejected) in zip(examples['chosen'], examples['rejected']):
        tokenized_chosen = tokenizer(chosen, truncation=True)
        tokenized_rejected = tokenizer(rejected, truncation=True)
        new_examples['input_ids_chosen'].append(tokenized_chosen['input_ids'])
        new_examples['attention_mask_chosen'].append(tokenized_chosen['attention_mask'])
        new_examples['input_ids_rejected'].append(tokenized_rejected['input_ids'])
        new_examples['attention_mask_rejected'].append(tokenized_rejected['attention_mask'])
    return new_examples

def get_target_modules(config):
    if config.target_modules is None:
        return TARGET_MODULES.get(config.model)
    if config.target_modules.strip() == '':
        return TARGET_MODULES.get(config.model)
    if config.target_modules.strip().lower() == 'all-linear':
        return 'all-linear'
    return config.target_modules.split(',')

def group_texts(examples, config):
    concatenated_examples = {k: list(chain(*examples[k])) for k in examples.keys()}
    total_length = len(concatenated_examples[list(examples.keys())[0]])
    if total_length >= config.block_size:
        total_length = total_length // config.block_size * config.block_size
    else:
        total_length = 0
    result = {k: [t[i:i + config.block_size] for i in range(0, total_length, config.block_size)] for (k, t) in concatenated_examples.items()}
    result['labels'] = result['input_ids'].copy()
    return result

def tokenize(examples, tokenizer, config):
    output = tokenizer(examples[config.text_column])
    return output

def merge_adapter(base_model_path, target_model_path, adapter_path):
    logger.info('Loading adapter...')
    model = AutoModelForCausalLM.from_pretrained(base_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True, trust_remote_code=ALLOW_REMOTE_CODE)
    tokenizer = AutoTokenizer.from_pretrained(target_model_path, trust_remote_code=ALLOW_REMOTE_CODE)
    try:
        model.resize_token_embeddings(len(tokenizer))
        model = PeftModel.from_pretrained(model, adapter_path)
    except RuntimeError:
        model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8)
        model = PeftModel.from_pretrained(model, adapter_path)
    model = model.merge_and_unload()
    logger.info('Saving target model...')
    model.save_pretrained(target_model_path)
    tokenizer.save_pretrained(target_model_path)

def create_model_card(config):
    if config.peft:
        peft = '\n- peft'
    else:
        peft = ''
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, peft=peft, base_model=base_model)
    return model_card.strip()

def pause_endpoint(params):
    endpoint_id = os.environ['ENDPOINT_ID']
    username = endpoint_id.split('/')[0]
    project_name = endpoint_id.split('/')[1]
    api_url = f'https://api.endpoints.huggingface.cloud/v2/endpoint/{username}/{project_name}/pause'
    headers = {'Authorization': f'Bearer {params.token}'}
    r = requests.post(api_url, headers=headers, timeout=30)
    return r.json()

def apply_chat_template(example, tokenizer, config):
    if config.trainer in ('default', 'sft'):
        messages = example[config.text_column]
        if isinstance(messages, str):
            messages = ast.literal_eval(messages)
        example[config.text_column] = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
    elif config.trainer == 'reward':
        if all((k in example.keys() for k in ('chosen', 'rejected'))):
            chosen_messages = example['chosen']
            rejected_messages = example['rejected']
            if isinstance(chosen_messages, str):
                chosen_messages = ast.literal_eval(chosen_messages)
            if isinstance(rejected_messages, str):
                rejected_messages = ast.literal_eval(rejected_messages)
            if config.chat_template == 'zephyr' and chosen_messages[0]['role'] != 'system':
                chosen_messages.insert(0, {'role': 'system', 'content': ''})
            if config.chat_template == 'zephyr' and rejected_messages[0]['role'] != 'system':
                rejected_messages.insert(0, {'role': 'system', 'content': ''})
            example['chosen'] = tokenizer.apply_chat_template(chosen_messages, tokenize=False)
            example['rejected'] = tokenizer.apply_chat_template(rejected_messages, tokenize=False)
        else:
            raise ValueError(f'Could not format example as dialogue for `rm/orpo` task! Require `[chosen, rejected]` keys but found {list(example.keys())}')
    elif config.trainer in ('dpo', 'orpo'):
        if all((k in example.keys() for k in ('chosen', 'rejected'))):
            if isinstance(example['chosen'], str):
                example['chosen'] = ast.literal_eval(example['chosen'])
            if isinstance(example['rejected'], str):
                example['rejected'] = ast.literal_eval(example['rejected'])
            prompt_messages = example['chosen'][:-1]
            if config.chat_template == 'zephyr' and example['chosen'][0]['role'] != 'system':
                prompt_messages.insert(0, {'role': 'system', 'content': ''})
            chosen_messages = example['chosen'][-1:]
            rejected_messages = example['rejected'][-1:]
            example['chosen'] = tokenizer.apply_chat_template(chosen_messages, tokenize=False)
            example['rejected'] = tokenizer.apply_chat_template(rejected_messages, tokenize=False)
            example['prompt'] = tokenizer.apply_chat_template(prompt_messages, tokenize=False)
    else:
        raise ValueError(f'Could not format example as dialogue for `dpo` task! Require `[chosen, rejected]` keys but found {list(example.keys())}')
    return example

def post_training_steps(config, trainer):
    logger.info('Finished training, saving model...')
    trainer.model.config.use_cache = True
    trainer.save_model(config.project_name)
    model_card = create_model_card(config)
    with open(f'{config.project_name}/README.md', 'w', encoding='utf-8') as f:
        f.write(model_card)
    if config.peft and config.merge_adapter:
        del trainer
        gc.collect()
        torch.cuda.empty_cache()
        logger.info('Merging adapter weights...')
        try:
            merge_adapter(base_model_path=config.model, target_model_path=config.project_name, adapter_path=config.project_name)
            for file in os.listdir(config.project_name):
                if file.startswith('adapter_'):
                    os.remove(f'{config.project_name}/{file}')
        except Exception as e:
            logger.warning(f'Failed to merge adapter weights: {e}')
            logger.warning('Skipping adapter merge. Only adapter weights will be saved.')
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            logger.info('Pushing model to hub...')
            save_training_params(config)
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)

def process_input_data(config):
    if config.data_path == f'{config.project_name}/autotrain-data':
        logger.info('loading dataset from disk')
        train_data = load_from_disk(config.data_path)[config.train_split]
    elif ':' in config.train_split:
        (dataset_config_name, split) = config.train_split.split(':')
        train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
    else:
        train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.trainer in ('dpo', 'reward', 'orpo'):
        if not (config.text_column == 'chosen' and config.text_column in train_data.column_names):
            train_data = train_data.rename_column(config.text_column, 'chosen')
        if not (config.rejected_text_column == 'rejected' and config.rejected_text_column in train_data.column_names):
            train_data = train_data.rename_column(config.rejected_text_column, 'rejected')
    if config.trainer in ('dpo', 'orpo'):
        if not (config.prompt_text_column == 'prompt' and config.prompt_text_column in train_data.column_names):
            train_data = train_data.rename_column(config.prompt_text_column, 'prompt')
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
        if config.trainer in ('dpo', 'reward', 'orpo'):
            if not (config.text_column == 'chosen' and config.text_column in valid_data.column_names):
                valid_data = valid_data.rename_column(config.text_column, 'chosen')
            if not (config.rejected_text_column == 'rejected' and config.rejected_text_column in valid_data.column_names):
                valid_data = valid_data.rename_column(config.rejected_text_column, 'rejected')
        if config.trainer in ('dpo', 'reward'):
            if not (config.prompt_text_column == 'prompt' and config.prompt_text_column in valid_data.column_names):
                valid_data = valid_data.rename_column(config.prompt_text_column, 'prompt')
    else:
        valid_data = None
    logger.info(f'Train data: {train_data}')
    logger.info(f'Valid data: {valid_data}')
    return (train_data, valid_data)

def get_tokenizer(config):
    special_tokens = None
    chat_template = None
    if config.chat_template == 'chatml':
        special_tokens = ChatmlSpecialTokens
        chat_template = CHATML_CHAT_TEMPLATE
    elif config.chat_template == 'zephyr':
        special_tokens = ZephyrSpecialTokens
        chat_template = ZEPHYR_CHAT_TEMPLATE
    if special_tokens is not None:
        tokenizer = AutoTokenizer.from_pretrained(config.model, pad_token=special_tokens.PAD_TOKEN.value, bos_token=special_tokens.BOS_TOKEN.value, eos_token=special_tokens.EOS_TOKEN.value, additional_special_tokens=special_tokens.list(), token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
        tokenizer.chat_template = chat_template
    else:
        tokenizer = AutoTokenizer.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
        if tokenizer.chat_template is None:
            tokenizer.chat_template = DEFAULT_CHAT_TEMPLATE
    if tokenizer.model_max_length > 2048:
        tokenizer.model_max_length = config.model_max_length
    if getattr(tokenizer, 'pad_token', None) is None:
        tokenizer.pad_token = tokenizer.eos_token
    if getattr(tokenizer, 'pad_token_id', None) is None:
        tokenizer.pad_token_id = tokenizer.eos_token_id
    if config.padding in ('left', 'right'):
        tokenizer.padding_side = config.padding
    return tokenizer

def process_data_with_chat_template(config, tokenizer, train_data, valid_data):
    valid_data = None
    if config.chat_template in ('chatml', 'zephyr', 'tokenizer'):
        logger.info('Applying chat template')
        logger.info('For ORPO/DPO, `prompt` will be extracted from chosen messages')
        train_data = train_data.map(apply_chat_template, fn_kwargs={'tokenizer': tokenizer, 'config': config})
        if config.valid_split is not None:
            valid_data = valid_data.map(apply_chat_template, fn_kwargs={'tokenizer': tokenizer, 'config': config})
    return (train_data, valid_data)

def configure_logging_steps(config, train_data, valid_data):
    logger.info('configuring logging steps')
    if config.logging_steps == -1:
        if config.valid_split is not None:
            logging_steps = int(0.2 * len(valid_data) / config.batch_size)
        else:
            logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    return logging_steps

def configure_training_args(config, logging_steps):
    logger.info('configuring training args')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False, gradient_checkpointing=not config.disable_gradient_checkpointing, remove_unused_columns=False)
    if not config.disable_gradient_checkpointing:
        if config.peft and config.quantization in ('int4', 'int8'):
            training_args['gradient_checkpointing_kwargs'] = {'use_reentrant': True}
        else:
            training_args['gradient_checkpointing_kwargs'] = {'use_reentrant': False}
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    return training_args

def configure_block_size(config, tokenizer):
    if config.block_size == -1:
        config.block_size = None
    if config.block_size is None:
        block_size = tokenizer.model_max_length
        if block_size > 1024:
            logger.warning('The chosen tokenizer supports a `model_max_length` that is longer than the default `block_size` value of 1024. If you would like to use a longer `block_size` up to `tokenizer.model_max_length` you can override this default with `--block_size xxx`.')
            block_size = 1024
    else:
        if config.block_size > tokenizer.model_max_length:
            logger.warning(f'The block_size passed ({config.block_size}) is larger than the maximum length for the model({tokenizer.model_max_length}). Using block_size={tokenizer.model_max_length}.')
        block_size = min(config.block_size, tokenizer.model_max_length)
    config.block_size = block_size
    logger.info(f'Using block size {block_size}')
    return config

def get_callbacks(config):
    is_deepspeed_enabled = os.environ.get('ACCELERATE_USE_DEEPSPEED', 'False').lower() == 'true'
    callbacks = [UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()]
    if config.peft and (not is_deepspeed_enabled):
        callbacks.append(SavePeftModelCallback)
        if config.valid_split is not None:
            callbacks.append(LoadBestPeftModelCallback)
    return callbacks

def get_model(config, tokenizer):
    model_config = AutoConfig.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    model_type = model_config.model_type
    unsloth_target_modules = None
    can_use_unloth = False
    if config.unsloth and is_unsloth_available() and (config.trainer in ('default', 'sft')):
        can_use_unloth = True
    if model_type in ('llama', 'mistral', 'gemma', 'qwen2') and config.unsloth:
        if config.target_modules.strip().lower() == 'all-linear':
            unsloth_target_modules = ['q_proj', 'k_proj', 'v_proj', 'o_proj', 'gate_proj', 'up_proj', 'down_proj']
        else:
            unsloth_target_modules = get_target_modules(config)
    else:
        can_use_unloth = False
    logger.info(f'Can use unsloth: {can_use_unloth}')
    if can_use_unloth:
        from unsloth import FastLanguageModel
        load_in_4bit = False
        load_in_8bit = False
        if config.peft and config.quantization == 'int4':
            load_in_4bit = True
        elif config.peft and config.quantization == 'int8':
            load_in_8bit = True
        dtype = None
        if config.mixed_precision == 'fp16':
            dtype = torch.float16
        elif config.mixed_precision == 'bf16':
            dtype = torch.bfloat16
        (model, _) = FastLanguageModel.from_pretrained(model_name=config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, load_in_4bit=load_in_4bit, load_in_8bit=load_in_8bit, max_seq_length=config.block_size, dtype=dtype)
        if config.peft:
            model = FastLanguageModel.get_peft_model(model, r=config.lora_r, target_modules=unsloth_target_modules, lora_alpha=config.lora_alpha, lora_dropout=config.lora_dropout, bias='none', use_gradient_checkpointing='unsloth', random_state=config.seed, max_seq_length=config.block_size, use_rslora=False, loftq_config=None)
        return model
    else:
        logger.warning('Unsloth not available, continuing without it...')
    logger.info('loading model config...')
    model_config = AutoConfig.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, use_cache=config.disable_gradient_checkpointing)
    logger.info('loading model...')
    if config.peft:
        if config.quantization == 'int4':
            bnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type='nf4', bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=False)
        elif config.quantization == 'int8':
            bnb_config = BitsAndBytesConfig(load_in_8bit=True)
        else:
            bnb_config = None
        model = AutoModelForCausalLM.from_pretrained(config.model, config=model_config, token=config.token, quantization_config=bnb_config, trust_remote_code=ALLOW_REMOTE_CODE, use_flash_attention_2=config.use_flash_attention_2)
    else:
        model = AutoModelForCausalLM.from_pretrained(config.model, config=model_config, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, use_flash_attention_2=config.use_flash_attention_2)
    logger.info(f'model dtype: {model.dtype}')
    model.resize_token_embeddings(len(tokenizer))
    if config.trainer != 'default':
        return model
    if config.peft:
        logger.info('preparing peft model...')
        if config.quantization is not None:
            gradient_checkpointing_kwargs = {}
            if not config.disable_gradient_checkpointing:
                if config.quantization in ('int4', 'int8'):
                    gradient_checkpointing_kwargs = {'use_reentrant': True}
                else:
                    gradient_checkpointing_kwargs = {'use_reentrant': False}
            model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=not config.disable_gradient_checkpointing, gradient_checkpointing_kwargs=gradient_checkpointing_kwargs)
        else:
            model.enable_input_require_grads()
        peft_config = LoraConfig(r=config.lora_r, lora_alpha=config.lora_alpha, lora_dropout=config.lora_dropout, bias='none', task_type='CAUSAL_LM', target_modules=get_target_modules(config))
        model = get_peft_model(model, peft_config)
    return model

# File: autotrain-advanced-main/src/autotrain/trainers/common.py
""""""
import json
import os
import shutil
import time
import traceback
import requests
from accelerate import PartialState
from huggingface_hub import HfApi
from pydantic import BaseModel
from transformers import TrainerCallback, TrainerControl, TrainerState, TrainingArguments
from autotrain import is_colab, logger
ALLOW_REMOTE_CODE = os.environ.get('ALLOW_REMOTE_CODE', 'true').lower() == 'true'

def get_file_sizes(directory):
    file_sizes = {}
    for (root, _, files) in os.walk(directory):
        for file in files:
            file_path = os.path.join(root, file)
            file_size = os.path.getsize(file_path)
            file_size_gb = file_size / 1024 ** 3
            file_sizes[file_path] = file_size_gb
    return file_sizes

def remove_global_step(directory):
    for (root, dirs, _) in os.walk(directory, topdown=False):
        for name in dirs:
            if name.startswith('global_step'):
                folder_path = os.path.join(root, name)
                print(f'Removing folder: {folder_path}')
                shutil.rmtree(folder_path)

def remove_autotrain_data(config):
    os.system(f'rm -rf {config.project_name}/autotrain-data')
    remove_global_step(config.project_name)

def save_training_params(config):
    if os.path.exists(f'{config.project_name}/training_params.json'):
        training_params = json.load(open(f'{config.project_name}/training_params.json'))
        if 'token' in training_params:
            training_params.pop('token')
            json.dump(training_params, open(f'{config.project_name}/training_params.json', 'w'), indent=4)

def pause_endpoint(params):
    if isinstance(params, dict):
        token = params['token']
    else:
        token = params.token
    endpoint_id = os.environ['ENDPOINT_ID']
    username = endpoint_id.split('/')[0]
    project_name = endpoint_id.split('/')[1]
    api_url = f'https://api.endpoints.huggingface.cloud/v2/endpoint/{username}/{project_name}/pause'
    headers = {'Authorization': f'Bearer {token}'}
    r = requests.post(api_url, headers=headers, timeout=120)
    return r.json()

def pause_space(params, is_failure=False):
    if 'SPACE_ID' in os.environ:
        logger.info('Pausing space...')
        api = HfApi(token=params.token)
        if is_failure:
            msg = 'Your training run has failed! Please check the logs for more details'
            title = 'Your training has failed ❌'
        else:
            msg = 'Your training run was successful! [Check out your trained model here]'
            msg += f'(https://huggingface.co/{params.username}/{params.project_name})'
            title = 'Your training has finished successfully ✅'
        if not params.token.startswith('hf_oauth_'):
            try:
                api.create_discussion(repo_id=os.environ['SPACE_ID'], title=title, description=msg, repo_type='space')
            except Exception as e:
                logger.warning(f'Failed to create discussion: {e}')
                if is_failure:
                    logger.error('Model failed to train and discussion was not created.')
                else:
                    logger.warning('Model trained successfully but discussion was not created.')
        api.pause_space(repo_id=os.environ['SPACE_ID'])
    if 'ENDPOINT_ID' in os.environ:
        logger.info('Pausing endpoint...')
        pause_endpoint(params)

def monitor(func):

    def wrapper(*args, **kwargs):
        config = kwargs.get('config', None)
        if config is None and len(args) > 0:
            config = args[0]
        try:
            return func(*args, **kwargs)
        except Exception as e:
            error_message = f'{func.__name__} has failed due to an exception: {traceback.format_exc()}'
            logger.error(error_message)
            logger.error(str(e))
            if int(os.environ.get('PAUSE_ON_FAILURE', 1)) == 1:
                pause_space(config, is_failure=True)
    return wrapper

class AutoTrainParams(BaseModel):

    class Config:
        protected_namespaces = ()

    def save(self, output_dir):
        os.makedirs(output_dir, exist_ok=True)
        path = os.path.join(output_dir, 'training_params.json')
        with open(path, 'w', encoding='utf-8') as f:
            f.write(self.model_dump_json(indent=4))

    def __str__(self):
        data = self.model_dump()
        data['token'] = '*****' if data.get('token') else None
        return str(data)

    def __init__(self, **data):
        super().__init__(**data)
        if len(self.project_name) > 0:
            if not self.project_name.replace('-', '').isalnum():
                raise ValueError('project_name must be alphanumeric but can contain hyphens')
        if len(self.project_name) > 50:
            raise ValueError('project_name cannot be more than 50 characters')
        defaults = set(self.model_fields.keys())
        supplied = set(data.keys())
        not_supplied = defaults - supplied
        if not_supplied and (not is_colab):
            logger.warning(f"Parameters not supplied by user and set to default: {', '.join(not_supplied)}")
        unused = supplied - set(self.model_fields)
        if unused:
            logger.warning(f"Parameters supplied but not used: {', '.join(unused)}")

class UploadLogs(TrainerCallback):

    def __init__(self, config):
        self.config = config
        self.api = None
        self.last_upload_time = 0
        if self.config.push_to_hub:
            if PartialState().process_index == 0:
                self.api = HfApi(token=config.token)
                self.api.create_repo(repo_id=f'{self.config.username}/{self.config.project_name}', repo_type='model', private=True)

    def on_step_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
        if self.config.push_to_hub is False:
            return control
        if not os.path.exists(os.path.join(self.config.project_name, 'runs')):
            return control
        if (state.global_step + 1) % self.config.logging_steps == 0 and self.config.log == 'tensorboard':
            if PartialState().process_index == 0:
                current_time = time.time()
                if current_time - self.last_upload_time >= 600:
                    try:
                        self.api.upload_folder(folder_path=os.path.join(self.config.project_name, 'runs'), repo_id=f'{self.config.username}/{self.config.project_name}', path_in_repo='runs')
                    except Exception as e:
                        logger.warning(f'Failed to upload logs: {e}')
                        logger.warning('Continuing training...')
                    self.last_upload_time = current_time
        return control

class LossLoggingCallback(TrainerCallback):

    def on_log(self, args, state, control, logs=None, **kwargs):
        _ = logs.pop('total_flos', None)
        if state.is_local_process_zero:
            logger.info(logs)

class TrainStartCallback(TrainerCallback):

    def on_train_begin(self, args, state, control, **kwargs):
        logger.info('Starting to train...')

# File: autotrain-advanced-main/src/autotrain/trainers/dreambooth/__main__.py
import argparse
import json
import os
from diffusers.utils import convert_all_state_dict_to_peft, convert_state_dict_to_kohya
from huggingface_hub import create_repo, snapshot_download, upload_folder
from safetensors.torch import load_file, save_file
from autotrain import logger
from autotrain.trainers.common import monitor, pause_space, remove_autotrain_data
from autotrain.trainers.dreambooth import utils
from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = DreamBoothTrainingParams(**config)
    config.prompt = str(config.prompt).strip()
    if config.model in utils.XL_MODELS:
        config.xl = True
    try:
        snapshot_download(repo_id=config.image_path, local_dir=config.project_name, token=config.token, repo_type='dataset')
        config.image_path = os.path.join(config.project_name, 'concept1')
    except Exception as e:
        logger.warning(f'Failed to download dataset: {e}')
        pass
    if config.image_path == f'{config.project_name}/autotrain-data':
        config.image_path = os.path.join(config.image_path, 'concept1')
    if config.vae_model is not None:
        if config.vae_model.strip() == '':
            config.vae_model = None
    if config.xl:
        from autotrain.trainers.dreambooth.train_xl import main

        class Args:
            pretrained_model_name_or_path = config.model
            pretrained_vae_model_name_or_path = config.vae_model
            revision = config.revision
            variant = None
            dataset_name = None
            dataset_config_name = None
            instance_data_dir = config.image_path
            cache_dir = None
            image_column = 'image'
            caption_column = None
            repeats = 1
            class_data_dir = config.class_image_path
            instance_prompt = config.prompt
            class_prompt = config.class_prompt
            validation_prompt = None
            num_validation_images = 4
            validation_epochs = 50
            with_prior_preservation = config.prior_preservation
            num_class_images = config.num_class_images
            output_dir = config.project_name
            seed = config.seed
            resolution = config.resolution
            center_crop = config.center_crop
            train_text_encoder = config.train_text_encoder
            train_batch_size = config.batch_size
            sample_batch_size = config.sample_batch_size
            num_train_epochs = config.epochs
            max_train_steps = config.num_steps
            checkpointing_steps = config.checkpointing_steps
            checkpoints_total_limit = None
            resume_from_checkpoint = config.resume_from_checkpoint
            gradient_accumulation_steps = config.gradient_accumulation
            gradient_checkpointing = not config.disable_gradient_checkpointing
            learning_rate = config.lr
            text_encoder_lr = 5e-06
            scale_lr = config.scale_lr
            lr_scheduler = config.scheduler
            snr_gamma = None
            lr_warmup_steps = config.warmup_steps
            lr_num_cycles = config.num_cycles
            lr_power = config.lr_power
            dataloader_num_workers = config.dataloader_num_workers
            optimizer = 'AdamW'
            use_8bit_adam = config.use_8bit_adam
            adam_beta1 = config.adam_beta1
            adam_beta2 = config.adam_beta2
            prodigy_beta3 = None
            prodigy_decouple = True
            adam_weight_decay = config.adam_weight_decay
            adam_weight_decay_text_encoder = 0.001
            adam_epsilon = config.adam_epsilon
            prodigy_use_bias_correction = True
            prodigy_safeguard_warmup = True
            max_grad_norm = config.max_grad_norm
            push_to_hub = config.push_to_hub
            hub_token = config.token
            hub_model_id = f'{config.username}/{config.project_name}'
            logging_dir = os.path.join(config.project_name, 'logs')
            allow_tf32 = config.allow_tf32
            report_to = 'tensorboard' if config.logging else None
            mixed_precision = config.mixed_precision
            prior_generation_precision = config.prior_generation_precision
            local_rank = config.local_rank
            enable_xformers_memory_efficient_attention = config.xformers
            rank = config.rank
            do_edm_style_training = False
            random_flip = False
            use_dora = False
        _args = Args()
        main(_args)
    else:
        from autotrain.trainers.dreambooth.train import main

        class Args:
            pretrained_model_name_or_path = config.model
            pretrained_vae_model_name_or_path = config.vae_model
            revision = config.revision
            variant = None
            tokenizer_name = None
            instance_data_dir = config.image_path
            class_data_dir = config.class_image_path
            instance_prompt = config.prompt
            class_prompt = config.class_prompt
            validation_prompt = None
            num_validation_images = 4
            validation_epochs = 50
            with_prior_preservation = config.prior_preservation
            num_class_images = config.num_class_images
            output_dir = config.project_name
            seed = config.seed
            resolution = config.resolution
            center_crop = config.center_crop
            train_text_encoder = config.train_text_encoder
            train_batch_size = config.batch_size
            sample_batch_size = config.sample_batch_size
            max_train_steps = config.num_steps
            checkpointing_steps = config.checkpointing_steps
            checkpoints_total_limit = None
            resume_from_checkpoint = config.resume_from_checkpoint
            gradient_accumulation_steps = config.gradient_accumulation
            gradient_checkpointing = not config.disable_gradient_checkpointing
            learning_rate = config.lr
            scale_lr = config.scale_lr
            lr_scheduler = config.scheduler
            lr_warmup_steps = config.warmup_steps
            lr_num_cycles = config.num_cycles
            lr_power = config.lr_power
            dataloader_num_workers = config.dataloader_num_workers
            use_8bit_adam = config.use_8bit_adam
            adam_beta1 = config.adam_beta1
            adam_beta2 = config.adam_beta2
            adam_weight_decay = config.adam_weight_decay
            adam_epsilon = config.adam_epsilon
            max_grad_norm = config.max_grad_norm
            push_to_hub = config.push_to_hub
            hub_token = config.token
            hub_model_id = f'{config.username}/{config.project_name}'
            logging_dir = os.path.join(config.project_name, 'logs')
            allow_tf32 = config.allow_tf32
            report_to = 'tensorboard' if config.logging else None
            mixed_precision = config.mixed_precision
            prior_generation_precision = config.prior_generation_precision
            local_rank = config.local_rank
            enable_xformers_memory_efficient_attention = config.xformers
            pre_compute_text_embeddings = config.pre_compute_text_embeddings
            tokenizer_max_length = config.tokenizer_max_length
            text_encoder_use_attention_mask = config.text_encoder_use_attention_mask
            validation_images = None
            class_labels_conditioning = config.class_labels_conditioning
            rank = config.rank
        _args = Args()
        main(_args)
    if os.path.exists(f'{config.project_name}/training_params.json'):
        training_params = json.load(open(f'{config.project_name}/training_params.json'))
        if 'token' in training_params:
            training_params.pop('token')
            json.dump(training_params, open(f'{config.project_name}/training_params.json', 'w'))
    with open(f'{config.project_name}/prompt.txt', 'w') as f:
        f.write(config.prompt)
    try:
        logger.info('Converting model to Kohya format...')
        lora_state_dict = load_file(f'{config.project_name}/pytorch_lora_weights.safetensors')
        peft_state_dict = convert_all_state_dict_to_peft(lora_state_dict)
        kohya_state_dict = convert_state_dict_to_kohya(peft_state_dict)
        save_file(kohya_state_dict, f'{config.project_name}/pytorch_lora_weights_kohya.safetensors')
    except Exception as e:
        logger.warning(e)
        logger.warning('Failed to convert model to Kohya format, skipping...')
    if config.push_to_hub:
        remove_autotrain_data(config)
        repo_id = create_repo(repo_id=f'{config.username}/{config.project_name}', exist_ok=True, private=True, token=config.token).repo_id
        if config.xl:
            utils.save_model_card_xl(repo_id, base_model=config.model, train_text_encoder=config.train_text_encoder, instance_prompt=config.prompt, vae_path=config.vae_model, repo_folder=config.project_name)
        else:
            utils.save_model_card(repo_id, base_model=config.model, train_text_encoder=config.train_text_encoder, instance_prompt=config.prompt, repo_folder=config.project_name)
        upload_folder(repo_id=repo_id, folder_path=config.project_name, commit_message='End of training', ignore_patterns=['step_*', 'epoch_*'], token=config.token)
    pause_space(config)
if __name__ == '__main__':
    args = parse_args()
    training_config = json.load(open(args.training_config))
    config = DreamBoothTrainingParams(**training_config)
    train(config)

# File: autotrain-advanced-main/src/autotrain/trainers/dreambooth/datasets.py
from pathlib import Path
import torch
from PIL import Image
from PIL.ImageOps import exif_transpose
from torch.utils.data import Dataset
from torchvision import transforms

class PromptDataset(Dataset):

    def __init__(self, prompt, num_samples):
        self.prompt = prompt
        self.num_samples = num_samples

    def __len__(self):
        return self.num_samples

    def __getitem__(self, index):
        example = {}
        example['prompt'] = self.prompt
        example['index'] = index
        return example

class DreamBoothDatasetXL(Dataset):

    def __init__(self, instance_data_root, class_data_root=None, class_num=None, size=1024, center_crop=False):
        self.size = size
        self.center_crop = center_crop
        self.instance_data_root = Path(instance_data_root)
        if not self.instance_data_root.exists():
            raise ValueError("Instance images root doesn't exists.")
        self.instance_images_path = list(Path(instance_data_root).iterdir())
        self.num_instance_images = len(self.instance_images_path)
        self._length = self.num_instance_images
        if class_data_root is not None:
            self.class_data_root = Path(class_data_root)
            self.class_data_root.mkdir(parents=True, exist_ok=True)
            self.class_images_path = list(self.class_data_root.iterdir())
            if class_num is not None:
                self.num_class_images = min(len(self.class_images_path), class_num)
            else:
                self.num_class_images = len(self.class_images_path)
            self._length = max(self.num_class_images, self.num_instance_images)
        else:
            self.class_data_root = None
        self.image_transforms = transforms.Compose([transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])])

    def __len__(self):
        return self._length

    def __getitem__(self, index):
        example = {}
        instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
        instance_image = exif_transpose(instance_image)
        if not instance_image.mode == 'RGB':
            instance_image = instance_image.convert('RGB')
        example['instance_images'] = self.image_transforms(instance_image)
        if self.class_data_root:
            class_image = Image.open(self.class_images_path[index % self.num_class_images])
            class_image = exif_transpose(class_image)
            if not class_image.mode == 'RGB':
                class_image = class_image.convert('RGB')
            example['class_images'] = self.image_transforms(class_image)
        return example

class DreamBoothDataset(Dataset):

    def __init__(self, config, tokenizers, encoder_hidden_states, instance_prompt_encoder_hidden_states):
        self.config = config
        self.tokenizer = tokenizers[0]
        self.size = self.config.resolution
        self.center_crop = self.config.center_crop
        self.tokenizer_max_length = self.config.tokenizer_max_length
        self.instance_data_root = Path(self.config.image_path)
        self.instance_prompt = self.config.prompt
        self.class_data_root = Path(self.config.class_image_path) if self.config.prior_preservation else None
        self.class_prompt = self.config.class_prompt
        self.class_num = self.config.num_class_images
        self.encoder_hidden_states = encoder_hidden_states
        self.instance_prompt_encoder_hidden_states = instance_prompt_encoder_hidden_states
        if not self.instance_data_root.exists():
            raise ValueError("Instance images root doesn't exists.")
        self.instance_images_path = list(Path(self.instance_data_root).iterdir())
        self.num_instance_images = len(self.instance_images_path)
        self._length = self.num_instance_images
        if self.class_data_root is not None:
            self.class_data_root.mkdir(parents=True, exist_ok=True)
            self.class_images_path = list(self.class_data_root.iterdir())
            if self.class_num is not None:
                self.num_class_images = min(len(self.class_images_path), self.class_num)
            else:
                self.num_class_images = len(self.class_images_path)
            self._length = max(self.num_class_images, self.num_instance_images)
        else:
            self.class_data_root = None
        self.image_transforms = transforms.Compose([transforms.Resize(self.size, interpolation=transforms.InterpolationMode.BILINEAR), transforms.CenterCrop(self.size) if self.center_crop else transforms.RandomCrop(self.size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])])

    def __len__(self):
        return self._length

    def _tokenize_prompt(self, tokenizer, prompt, tokenizer_max_length=None):
        if tokenizer_max_length is not None:
            max_length = tokenizer_max_length
        else:
            max_length = tokenizer.model_max_length
        text_inputs = tokenizer(prompt, truncation=True, padding='max_length', max_length=max_length, return_tensors='pt')
        return text_inputs

    def __getitem__(self, index):
        example = {}
        instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
        instance_image = exif_transpose(instance_image)
        if not instance_image.mode == 'RGB':
            instance_image = instance_image.convert('RGB')
        example['instance_images'] = self.image_transforms(instance_image)
        if not self.config.xl:
            if self.encoder_hidden_states is not None:
                example['instance_prompt_ids'] = self.encoder_hidden_states
            else:
                text_inputs = self._tokenize_prompt(self.tokenizer, self.instance_prompt, tokenizer_max_length=self.tokenizer_max_length)
                example['instance_prompt_ids'] = text_inputs.input_ids
                example['instance_attention_mask'] = text_inputs.attention_mask
        if self.class_data_root:
            class_image = Image.open(self.class_images_path[index % self.num_class_images])
            class_image = exif_transpose(class_image)
            if not class_image.mode == 'RGB':
                class_image = class_image.convert('RGB')
            example['class_images'] = self.image_transforms(class_image)
            if not self.config.xl:
                if self.instance_prompt_encoder_hidden_states is not None:
                    example['class_prompt_ids'] = self.instance_prompt_encoder_hidden_states
                else:
                    class_text_inputs = self._tokenize_prompt(self.tokenizer, self.class_prompt, tokenizer_max_length=self.tokenizer_max_length)
                    example['class_prompt_ids'] = class_text_inputs.input_ids
                    example['class_attention_mask'] = class_text_inputs.attention_mask
        return example

def collate_fn(examples, config):
    pixel_values = [example['instance_images'] for example in examples]
    if not config.xl:
        has_attention_mask = 'instance_attention_mask' in examples[0]
        input_ids = [example['instance_prompt_ids'] for example in examples]
        if has_attention_mask:
            attention_mask = [example['instance_attention_mask'] for example in examples]
    if config.prior_preservation:
        pixel_values += [example['class_images'] for example in examples]
        if not config.xl:
            input_ids += [example['class_prompt_ids'] for example in examples]
            if has_attention_mask:
                attention_mask += [example['class_attention_mask'] for example in examples]
    pixel_values = torch.stack(pixel_values)
    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
    batch = {'pixel_values': pixel_values}
    if not config.xl:
        input_ids = torch.cat(input_ids, dim=0)
        batch['input_ids'] = input_ids
        if has_attention_mask:
            batch['attention_mask'] = attention_mask
    return batch

# File: autotrain-advanced-main/src/autotrain/trainers/dreambooth/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class DreamBoothTrainingParams(AutoTrainParams):
    model: str = Field(None, title='Model name')
    vae_model: Optional[str] = Field(None, title='VAE model name')
    revision: Optional[str] = Field(None, title='Revision')
    tokenizer: Optional[str] = Field(None, title='Tokenizer, if different from model')
    image_path: str = Field(None, title='Image path')
    class_image_path: Optional[str] = Field(None, title='Class image path')
    prompt: str = Field(None, title='Instance prompt')
    class_prompt: Optional[str] = Field(None, title='Class prompt')
    num_class_images: int = Field(100, title='Number of class images')
    class_labels_conditioning: Optional[str] = Field(None, title='Class labels conditioning')
    prior_preservation: bool = Field(False, title='With prior preservation')
    prior_loss_weight: float = Field(1.0, title='Prior loss weight')
    project_name: str = Field('dreambooth-model', title='Output directory')
    seed: int = Field(42, title='Seed')
    resolution: int = Field(512, title='Resolution')
    center_crop: bool = Field(False, title='Center crop')
    train_text_encoder: bool = Field(False, title='Train text encoder')
    batch_size: int = Field(4, title='Train batch size')
    sample_batch_size: int = Field(4, title='Sample batch size')
    epochs: int = Field(1, title='Number of training epochs')
    num_steps: int = Field(None, title='Max train steps')
    checkpointing_steps: int = Field(500, title='Checkpointing steps')
    resume_from_checkpoint: Optional[str] = Field(None, title='Resume from checkpoint')
    gradient_accumulation: int = Field(1, title='Gradient accumulation steps')
    disable_gradient_checkpointing: bool = Field(False, title='Gradient checkpointing')
    lr: float = Field(0.0001, title='Learning rate')
    scale_lr: bool = Field(False, title='Scale learning rate')
    scheduler: str = Field('constant', title='Learning rate scheduler')
    warmup_steps: int = Field(0, title='Learning rate warmup steps')
    num_cycles: int = Field(1, title='Learning rate num cycles')
    lr_power: float = Field(1.0, title='Learning rate power')
    dataloader_num_workers: int = Field(0, title='Dataloader num workers')
    use_8bit_adam: bool = Field(False, title='Use 8bit adam')
    adam_beta1: float = Field(0.9, title='Adam beta 1')
    adam_beta2: float = Field(0.999, title='Adam beta 2')
    adam_weight_decay: float = Field(0.01, title='Adam weight decay')
    adam_epsilon: float = Field(1e-08, title='Adam epsilon')
    max_grad_norm: float = Field(1.0, title='Max grad norm')
    allow_tf32: bool = Field(False, title='Allow TF32')
    prior_generation_precision: Optional[str] = Field(None, title='Prior generation precision')
    local_rank: int = Field(-1, title='Local rank')
    xformers: bool = Field(False, title='Enable xformers memory efficient attention')
    pre_compute_text_embeddings: bool = Field(False, title='Pre compute text embeddings')
    tokenizer_max_length: Optional[int] = Field(None, title='Tokenizer max length')
    text_encoder_use_attention_mask: bool = Field(False, title='Text encoder use attention mask')
    rank: int = Field(4, title='Rank')
    xl: bool = Field(False, title='XL')
    mixed_precision: Optional[str] = Field(None, title='Mixed precision')
    token: Optional[str] = Field(None, title='Hub token')
    push_to_hub: bool = Field(False, title='Push to hub')
    username: Optional[str] = Field(None, title='Hub username')
    validation_prompt: Optional[str] = Field(None, title='Validation prompt')
    num_validation_images: int = Field(4, title='Number of validation images')
    validation_epochs: int = Field(50, title='Validation epochs')
    checkpoints_total_limit: Optional[int] = Field(None, title='Checkpoints total limit')
    validation_images: Optional[str] = Field(None, title='Validation images')
    logging: bool = Field(False, title='Logging using tensorboard')

# File: autotrain-advanced-main/src/autotrain/trainers/dreambooth/train.py
import copy
import gc
import logging
import math
import os
import shutil
from pathlib import Path
import diffusers
import numpy as np
import torch
import torch.nn.functional as F
import torch.utils.checkpoint
import transformers
from accelerate import Accelerator
from accelerate.utils import ProjectConfiguration, set_seed
from diffusers import AutoencoderKL, DDPMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, UNet2DConditionModel
from diffusers.loaders import LoraLoaderMixin
from diffusers.optimization import get_scheduler
from diffusers.training_utils import _set_state_dict_into_text_encoder, cast_training_params
from diffusers.utils import convert_state_dict_to_diffusers, convert_unet_state_dict_to_peft, is_wandb_available
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.torch_utils import is_compiled_module
from huggingface_hub.utils import insecure_hashlib
from packaging import version
from peft import LoraConfig
from peft.utils import get_peft_model_state_dict, set_peft_model_state_dict
from PIL import Image
from PIL.ImageOps import exif_transpose
from torch.utils.data import Dataset
from torchvision import transforms
from tqdm.auto import tqdm
from transformers import AutoTokenizer, PretrainedConfig
from autotrain import logger

def log_validation(pipeline, args, accelerator, pipeline_args, epoch, is_final_validation=False):
    logger.info(f'Running validation... \n Generating {args.num_validation_images} images with prompt: {args.validation_prompt}.')
    scheduler_args = {}
    if 'variance_type' in pipeline.scheduler.config:
        variance_type = pipeline.scheduler.config.variance_type
        if variance_type in ['learned', 'learned_range']:
            variance_type = 'fixed_small'
        scheduler_args['variance_type'] = variance_type
    pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config, **scheduler_args)
    pipeline = pipeline.to(accelerator.device)
    pipeline.set_progress_bar_config(disable=True)
    generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) if args.seed else None
    if args.validation_images is None:
        images = []
        for _ in range(args.num_validation_images):
            with torch.cuda.amp.autocast():
                image = pipeline(**pipeline_args, generator=generator).images[0]
                images.append(image)
    else:
        images = []
        for image in args.validation_images:
            image = Image.open(image)
            with torch.cuda.amp.autocast():
                image = pipeline(**pipeline_args, image=image, generator=generator).images[0]
            images.append(image)
    for tracker in accelerator.trackers:
        phase_name = 'test' if is_final_validation else 'validation'
        if tracker.name == 'tensorboard':
            np_images = np.stack([np.asarray(img) for img in images])
            tracker.writer.add_images(phase_name, np_images, epoch, dataformats='NHWC')
    del pipeline
    torch.cuda.empty_cache()
    return images

def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str):
    text_encoder_config = PretrainedConfig.from_pretrained(pretrained_model_name_or_path, subfolder='text_encoder', revision=revision)
    model_class = text_encoder_config.architectures[0]
    if model_class == 'CLIPTextModel':
        from transformers import CLIPTextModel
        return CLIPTextModel
    elif model_class == 'RobertaSeriesModelWithTransformation':
        from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation
        return RobertaSeriesModelWithTransformation
    elif model_class == 'T5EncoderModel':
        from transformers import T5EncoderModel
        return T5EncoderModel
    else:
        raise ValueError(f'{model_class} is not supported.')

class DreamBoothDataset(Dataset):

    def __init__(self, instance_data_root, instance_prompt, tokenizer, class_data_root=None, class_prompt=None, class_num=None, size=512, center_crop=False, encoder_hidden_states=None, class_prompt_encoder_hidden_states=None, tokenizer_max_length=None):
        self.size = size
        self.center_crop = center_crop
        self.tokenizer = tokenizer
        self.encoder_hidden_states = encoder_hidden_states
        self.class_prompt_encoder_hidden_states = class_prompt_encoder_hidden_states
        self.tokenizer_max_length = tokenizer_max_length
        self.instance_data_root = Path(instance_data_root)
        if not self.instance_data_root.exists():
            raise ValueError("Instance images root doesn't exists.")
        self.instance_images_path = list(Path(instance_data_root).iterdir())
        self.num_instance_images = len(self.instance_images_path)
        self.instance_prompt = instance_prompt
        self._length = self.num_instance_images
        if class_data_root is not None:
            self.class_data_root = Path(class_data_root)
            self.class_data_root.mkdir(parents=True, exist_ok=True)
            self.class_images_path = list(self.class_data_root.iterdir())
            if class_num is not None:
                self.num_class_images = min(len(self.class_images_path), class_num)
            else:
                self.num_class_images = len(self.class_images_path)
            self._length = max(self.num_class_images, self.num_instance_images)
            self.class_prompt = class_prompt
        else:
            self.class_data_root = None
        self.image_transforms = transforms.Compose([transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])])

    def __len__(self):
        return self._length

    def __getitem__(self, index):
        example = {}
        instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
        instance_image = exif_transpose(instance_image)
        if not instance_image.mode == 'RGB':
            instance_image = instance_image.convert('RGB')
        example['instance_images'] = self.image_transforms(instance_image)
        if self.encoder_hidden_states is not None:
            example['instance_prompt_ids'] = self.encoder_hidden_states
        else:
            text_inputs = tokenize_prompt(self.tokenizer, self.instance_prompt, tokenizer_max_length=self.tokenizer_max_length)
            example['instance_prompt_ids'] = text_inputs.input_ids
            example['instance_attention_mask'] = text_inputs.attention_mask
        if self.class_data_root:
            class_image = Image.open(self.class_images_path[index % self.num_class_images])
            class_image = exif_transpose(class_image)
            if not class_image.mode == 'RGB':
                class_image = class_image.convert('RGB')
            example['class_images'] = self.image_transforms(class_image)
            if self.class_prompt_encoder_hidden_states is not None:
                example['class_prompt_ids'] = self.class_prompt_encoder_hidden_states
            else:
                class_text_inputs = tokenize_prompt(self.tokenizer, self.class_prompt, tokenizer_max_length=self.tokenizer_max_length)
                example['class_prompt_ids'] = class_text_inputs.input_ids
                example['class_attention_mask'] = class_text_inputs.attention_mask
        return example

def collate_fn(examples, with_prior_preservation=False):
    has_attention_mask = 'instance_attention_mask' in examples[0]
    input_ids = [example['instance_prompt_ids'] for example in examples]
    pixel_values = [example['instance_images'] for example in examples]
    if has_attention_mask:
        attention_mask = [example['instance_attention_mask'] for example in examples]
    if with_prior_preservation:
        input_ids += [example['class_prompt_ids'] for example in examples]
        pixel_values += [example['class_images'] for example in examples]
        if has_attention_mask:
            attention_mask += [example['class_attention_mask'] for example in examples]
    pixel_values = torch.stack(pixel_values)
    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
    input_ids = torch.cat(input_ids, dim=0)
    batch = {'input_ids': input_ids, 'pixel_values': pixel_values}
    if has_attention_mask:
        batch['attention_mask'] = attention_mask
    return batch

class PromptDataset(Dataset):

    def __init__(self, prompt, num_samples):
        self.prompt = prompt
        self.num_samples = num_samples

    def __len__(self):
        return self.num_samples

    def __getitem__(self, index):
        example = {}
        example['prompt'] = self.prompt
        example['index'] = index
        return example

def tokenize_prompt(tokenizer, prompt, tokenizer_max_length=None):
    if tokenizer_max_length is not None:
        max_length = tokenizer_max_length
    else:
        max_length = tokenizer.model_max_length
    text_inputs = tokenizer(prompt, truncation=True, padding='max_length', max_length=max_length, return_tensors='pt')
    return text_inputs

def encode_prompt(text_encoder, input_ids, attention_mask, text_encoder_use_attention_mask=None):
    text_input_ids = input_ids.to(text_encoder.device)
    if text_encoder_use_attention_mask:
        attention_mask = attention_mask.to(text_encoder.device)
    else:
        attention_mask = None
    prompt_embeds = text_encoder(text_input_ids, attention_mask=attention_mask, return_dict=False)
    prompt_embeds = prompt_embeds[0]
    return prompt_embeds

def main(args):
    if args.report_to == 'wandb' and args.hub_token is not None:
        raise ValueError('You cannot use both --report_to=wandb and --hub_token due to a security risk of exposing your token. Please use `huggingface-cli login` to authenticate with the Hub.')
    logging_dir = Path(args.output_dir, args.logging_dir)
    accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir)
    accelerator = Accelerator(gradient_accumulation_steps=args.gradient_accumulation_steps, mixed_precision=args.mixed_precision, log_with=args.report_to, project_config=accelerator_project_config)
    if args.report_to == 'wandb':
        if not is_wandb_available():
            raise ImportError('Make sure to install wandb if you want to use it for logging during training.')
    if args.train_text_encoder and args.gradient_accumulation_steps > 1 and (accelerator.num_processes > 1):
        raise ValueError('Gradient accumulation is not supported when training the text encoder in distributed training. Please set gradient_accumulation_steps to 1. This feature will be supported in the future.')
    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO)
    if accelerator.is_local_main_process:
        transformers.utils.logging.set_verbosity_warning()
        diffusers.utils.logging.set_verbosity_info()
    else:
        transformers.utils.logging.set_verbosity_error()
        diffusers.utils.logging.set_verbosity_error()
    if args.seed is not None:
        set_seed(args.seed)
    if args.with_prior_preservation:
        class_images_dir = Path(args.class_data_dir)
        if not class_images_dir.exists():
            class_images_dir.mkdir(parents=True)
        cur_class_images = len(list(class_images_dir.iterdir()))
        if cur_class_images < args.num_class_images:
            torch_dtype = torch.float16 if accelerator.device.type == 'cuda' else torch.float32
            if args.prior_generation_precision == 'fp32':
                torch_dtype = torch.float32
            elif args.prior_generation_precision == 'fp16':
                torch_dtype = torch.float16
            elif args.prior_generation_precision == 'bf16':
                torch_dtype = torch.bfloat16
            pipeline = DiffusionPipeline.from_pretrained(args.pretrained_model_name_or_path, torch_dtype=torch_dtype, safety_checker=None, revision=args.revision, variant=args.variant)
            pipeline.set_progress_bar_config(disable=True)
            num_new_images = args.num_class_images - cur_class_images
            logger.info(f'Number of class images to sample: {num_new_images}.')
            sample_dataset = PromptDataset(args.class_prompt, num_new_images)
            sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
            sample_dataloader = accelerator.prepare(sample_dataloader)
            pipeline.to(accelerator.device)
            for example in tqdm(sample_dataloader, desc='Generating class images', disable=not accelerator.is_local_main_process):
                images = pipeline(example['prompt']).images
                for (i, image) in enumerate(images):
                    hash_image = insecure_hashlib.sha1(image.tobytes()).hexdigest()
                    image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg"
                    image.save(image_filename)
            del pipeline
            if torch.cuda.is_available():
                torch.cuda.empty_cache()
    if accelerator.is_main_process:
        if args.output_dir is not None:
            os.makedirs(args.output_dir, exist_ok=True)
    if args.tokenizer_name:
        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
    elif args.pretrained_model_name_or_path:
        tokenizer = AutoTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder='tokenizer', revision=args.revision, use_fast=False)
    text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
    noise_scheduler = DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder='scheduler')
    text_encoder = text_encoder_cls.from_pretrained(args.pretrained_model_name_or_path, subfolder='text_encoder', revision=args.revision, variant=args.variant)
    vae_path = args.pretrained_model_name_or_path if args.pretrained_vae_model_name_or_path is None else args.pretrained_vae_model_name_or_path
    try:
        vae = AutoencoderKL.from_pretrained(vae_path, subfolder='vae' if args.pretrained_vae_model_name_or_path is None else None, revision=args.revision, variant=args.variant)
    except OSError:
        vae = None
    unet = UNet2DConditionModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='unet', revision=args.revision, variant=args.variant)
    if vae is not None:
        vae.requires_grad_(False)
    text_encoder.requires_grad_(False)
    unet.requires_grad_(False)
    weight_dtype = torch.float32
    if accelerator.mixed_precision == 'fp16':
        weight_dtype = torch.float16
    elif accelerator.mixed_precision == 'bf16':
        weight_dtype = torch.bfloat16
    unet.to(accelerator.device, dtype=weight_dtype)
    if vae is not None:
        vae.to(accelerator.device, dtype=weight_dtype)
    text_encoder.to(accelerator.device, dtype=weight_dtype)
    if args.enable_xformers_memory_efficient_attention:
        if is_xformers_available():
            import xformers
            xformers_version = version.parse(xformers.__version__)
            if xformers_version == version.parse('0.0.16'):
                logger.warning('xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details.')
            unet.enable_xformers_memory_efficient_attention()
        else:
            raise ValueError('xformers is not available. Make sure it is installed correctly')
    if args.gradient_checkpointing:
        unet.enable_gradient_checkpointing()
        if args.train_text_encoder:
            text_encoder.gradient_checkpointing_enable()
    unet_lora_config = LoraConfig(r=args.rank, lora_alpha=args.rank, init_lora_weights='gaussian', target_modules=['to_k', 'to_q', 'to_v', 'to_out.0', 'add_k_proj', 'add_v_proj'])
    unet.add_adapter(unet_lora_config)
    if args.train_text_encoder:
        text_lora_config = LoraConfig(r=args.rank, lora_alpha=args.rank, init_lora_weights='gaussian', target_modules=['q_proj', 'k_proj', 'v_proj', 'out_proj'])
        text_encoder.add_adapter(text_lora_config)

    def unwrap_model(model):
        model = accelerator.unwrap_model(model)
        model = model._orig_mod if is_compiled_module(model) else model
        return model

    def save_model_hook(models, weights, output_dir):
        if accelerator.is_main_process:
            unet_lora_layers_to_save = None
            text_encoder_lora_layers_to_save = None
            for model in models:
                if isinstance(model, type(unwrap_model(unet))):
                    unet_lora_layers_to_save = convert_state_dict_to_diffusers(get_peft_model_state_dict(model))
                elif isinstance(model, type(unwrap_model(text_encoder))):
                    text_encoder_lora_layers_to_save = convert_state_dict_to_diffusers(get_peft_model_state_dict(model))
                else:
                    raise ValueError(f'unexpected save model: {model.__class__}')
                weights.pop()
            LoraLoaderMixin.save_lora_weights(output_dir, unet_lora_layers=unet_lora_layers_to_save, text_encoder_lora_layers=text_encoder_lora_layers_to_save)

    def load_model_hook(models, input_dir):
        unet_ = None
        text_encoder_ = None
        while len(models) > 0:
            model = models.pop()
            if isinstance(model, type(unwrap_model(unet))):
                unet_ = model
            elif isinstance(model, type(unwrap_model(text_encoder))):
                text_encoder_ = model
            else:
                raise ValueError(f'unexpected save model: {model.__class__}')
        (lora_state_dict, network_alphas) = LoraLoaderMixin.lora_state_dict(input_dir)
        unet_state_dict = {f"{k.replace('unet.', '')}": v for (k, v) in lora_state_dict.items() if k.startswith('unet.')}
        unet_state_dict = convert_unet_state_dict_to_peft(unet_state_dict)
        incompatible_keys = set_peft_model_state_dict(unet_, unet_state_dict, adapter_name='default')
        if incompatible_keys is not None:
            unexpected_keys = getattr(incompatible_keys, 'unexpected_keys', None)
            if unexpected_keys:
                logger.warning(f'Loading adapter weights from state_dict led to unexpected keys not found in the model:  {unexpected_keys}. ')
        if args.train_text_encoder:
            _set_state_dict_into_text_encoder(lora_state_dict, prefix='text_encoder.', text_encoder=text_encoder_)
        if args.mixed_precision == 'fp16':
            models = [unet_]
            if args.train_text_encoder:
                models.append(text_encoder_)
            cast_training_params(models, dtype=torch.float32)
    accelerator.register_save_state_pre_hook(save_model_hook)
    accelerator.register_load_state_pre_hook(load_model_hook)
    if args.allow_tf32:
        torch.backends.cuda.matmul.allow_tf32 = True
    if args.scale_lr:
        args.learning_rate = args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
    if args.mixed_precision == 'fp16':
        models = [unet]
        if args.train_text_encoder:
            models.append(text_encoder)
        cast_training_params(models, dtype=torch.float32)
    if args.use_8bit_adam:
        try:
            import bitsandbytes as bnb
        except ImportError:
            raise ImportError('To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`.')
        optimizer_class = bnb.optim.AdamW8bit
    else:
        optimizer_class = torch.optim.AdamW
    params_to_optimize = list(filter(lambda p: p.requires_grad, unet.parameters()))
    if args.train_text_encoder:
        params_to_optimize = params_to_optimize + list(filter(lambda p: p.requires_grad, text_encoder.parameters()))
    optimizer = optimizer_class(params_to_optimize, lr=args.learning_rate, betas=(args.adam_beta1, args.adam_beta2), weight_decay=args.adam_weight_decay, eps=args.adam_epsilon)
    if args.pre_compute_text_embeddings:

        def compute_text_embeddings(prompt):
            with torch.no_grad():
                text_inputs = tokenize_prompt(tokenizer, prompt, tokenizer_max_length=args.tokenizer_max_length)
                prompt_embeds = encode_prompt(text_encoder, text_inputs.input_ids, text_inputs.attention_mask, text_encoder_use_attention_mask=args.text_encoder_use_attention_mask)
            return prompt_embeds
        pre_computed_encoder_hidden_states = compute_text_embeddings(args.instance_prompt)
        validation_prompt_negative_prompt_embeds = compute_text_embeddings('')
        if args.validation_prompt is not None:
            validation_prompt_encoder_hidden_states = compute_text_embeddings(args.validation_prompt)
        else:
            validation_prompt_encoder_hidden_states = None
        if args.class_prompt is not None:
            pre_computed_class_prompt_encoder_hidden_states = compute_text_embeddings(args.class_prompt)
        else:
            pre_computed_class_prompt_encoder_hidden_states = None
        text_encoder = None
        tokenizer = None
        gc.collect()
        torch.cuda.empty_cache()
    else:
        pre_computed_encoder_hidden_states = None
        validation_prompt_encoder_hidden_states = None
        validation_prompt_negative_prompt_embeds = None
        pre_computed_class_prompt_encoder_hidden_states = None
    train_dataset = DreamBoothDataset(instance_data_root=args.instance_data_dir, instance_prompt=args.instance_prompt, class_data_root=args.class_data_dir if args.with_prior_preservation else None, class_prompt=args.class_prompt, class_num=args.num_class_images, tokenizer=tokenizer, size=args.resolution, center_crop=args.center_crop, encoder_hidden_states=pre_computed_encoder_hidden_states, class_prompt_encoder_hidden_states=pre_computed_class_prompt_encoder_hidden_states, tokenizer_max_length=args.tokenizer_max_length)
    train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=args.train_batch_size, shuffle=True, collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation), num_workers=args.dataloader_num_workers)
    overrode_max_train_steps = False
    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
    if args.max_train_steps is None:
        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
        overrode_max_train_steps = True
    lr_scheduler = get_scheduler(args.lr_scheduler, optimizer=optimizer, num_warmup_steps=args.lr_warmup_steps * accelerator.num_processes, num_training_steps=args.max_train_steps * accelerator.num_processes, num_cycles=args.lr_num_cycles, power=args.lr_power)
    if args.train_text_encoder:
        (unet, text_encoder, optimizer, train_dataloader, lr_scheduler) = accelerator.prepare(unet, text_encoder, optimizer, train_dataloader, lr_scheduler)
    else:
        (unet, optimizer, train_dataloader, lr_scheduler) = accelerator.prepare(unet, optimizer, train_dataloader, lr_scheduler)
    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
    if overrode_max_train_steps:
        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
    if accelerator.is_main_process:
        tracker_config = vars(copy.deepcopy(args))
        accelerator.init_trackers('dreambooth-lora', config=tracker_config)
    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
    logger.info('***** Running training *****')
    logger.info(f'  Num examples = {len(train_dataset)}')
    logger.info(f'  Num batches each epoch = {len(train_dataloader)}')
    logger.info(f'  Num Epochs = {args.num_train_epochs}')
    logger.info(f'  Instantaneous batch size per device = {args.train_batch_size}')
    logger.info(f'  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}')
    logger.info(f'  Gradient Accumulation steps = {args.gradient_accumulation_steps}')
    logger.info(f'  Total optimization steps = {args.max_train_steps}')
    global_step = 0
    first_epoch = 0
    if args.resume_from_checkpoint:
        if args.resume_from_checkpoint != 'latest':
            path = os.path.basename(args.resume_from_checkpoint)
        else:
            dirs = os.listdir(args.output_dir)
            dirs = [d for d in dirs if d.startswith('checkpoint')]
            dirs = sorted(dirs, key=lambda x: int(x.split('-')[1]))
            path = dirs[-1] if len(dirs) > 0 else None
        if path is None:
            accelerator.print(f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run.")
            args.resume_from_checkpoint = None
            initial_global_step = 0
        else:
            accelerator.print(f'Resuming from checkpoint {path}')
            accelerator.load_state(os.path.join(args.output_dir, path))
            global_step = int(path.split('-')[1])
            initial_global_step = global_step
            first_epoch = global_step // num_update_steps_per_epoch
    else:
        initial_global_step = 0
    progress_bar = tqdm(range(0, args.max_train_steps), initial=initial_global_step, desc='Steps', disable=not accelerator.is_local_main_process)
    for epoch in range(first_epoch, args.num_train_epochs):
        unet.train()
        if args.train_text_encoder:
            text_encoder.train()
        for (step, batch) in enumerate(train_dataloader):
            with accelerator.accumulate(unet):
                pixel_values = batch['pixel_values'].to(dtype=weight_dtype)
                if vae is not None:
                    model_input = vae.encode(pixel_values).latent_dist.sample()
                    model_input = model_input * vae.config.scaling_factor
                else:
                    model_input = pixel_values
                noise = torch.randn_like(model_input)
                (bsz, channels, height, width) = model_input.shape
                timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=model_input.device)
                timesteps = timesteps.long()
                noisy_model_input = noise_scheduler.add_noise(model_input, noise, timesteps)
                if args.pre_compute_text_embeddings:
                    encoder_hidden_states = batch['input_ids']
                else:
                    encoder_hidden_states = encode_prompt(text_encoder, batch['input_ids'], batch['attention_mask'], text_encoder_use_attention_mask=args.text_encoder_use_attention_mask)
                if unwrap_model(unet).config.in_channels == channels * 2:
                    noisy_model_input = torch.cat([noisy_model_input, noisy_model_input], dim=1)
                if args.class_labels_conditioning == 'timesteps':
                    class_labels = timesteps
                else:
                    class_labels = None
                model_pred = unet(noisy_model_input, timesteps, encoder_hidden_states, class_labels=class_labels, return_dict=False)[0]
                if model_pred.shape[1] == 6:
                    (model_pred, _) = torch.chunk(model_pred, 2, dim=1)
                if noise_scheduler.config.prediction_type == 'epsilon':
                    target = noise
                elif noise_scheduler.config.prediction_type == 'v_prediction':
                    target = noise_scheduler.get_velocity(model_input, noise, timesteps)
                else:
                    raise ValueError(f'Unknown prediction type {noise_scheduler.config.prediction_type}')
                if args.with_prior_preservation:
                    (model_pred, model_pred_prior) = torch.chunk(model_pred, 2, dim=0)
                    (target, target_prior) = torch.chunk(target, 2, dim=0)
                    loss = F.mse_loss(model_pred.float(), target.float(), reduction='mean')
                    prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction='mean')
                    loss = loss + args.prior_loss_weight * prior_loss
                else:
                    loss = F.mse_loss(model_pred.float(), target.float(), reduction='mean')
                accelerator.backward(loss)
                if accelerator.sync_gradients:
                    accelerator.clip_grad_norm_(params_to_optimize, args.max_grad_norm)
                optimizer.step()
                lr_scheduler.step()
                optimizer.zero_grad()
            if accelerator.sync_gradients:
                progress_bar.update(1)
                global_step += 1
                if accelerator.is_main_process:
                    if global_step % args.checkpointing_steps == 0:
                        if args.checkpoints_total_limit is not None:
                            checkpoints = os.listdir(args.output_dir)
                            checkpoints = [d for d in checkpoints if d.startswith('checkpoint')]
                            checkpoints = sorted(checkpoints, key=lambda x: int(x.split('-')[1]))
                            if len(checkpoints) >= args.checkpoints_total_limit:
                                num_to_remove = len(checkpoints) - args.checkpoints_total_limit + 1
                                removing_checkpoints = checkpoints[0:num_to_remove]
                                logger.info(f'{len(checkpoints)} checkpoints already exist, removing {len(removing_checkpoints)} checkpoints')
                                logger.info(f"removing checkpoints: {', '.join(removing_checkpoints)}")
                                for removing_checkpoint in removing_checkpoints:
                                    removing_checkpoint = os.path.join(args.output_dir, removing_checkpoint)
                                    shutil.rmtree(removing_checkpoint)
                        save_path = os.path.join(args.output_dir, f'checkpoint-{global_step}')
                        accelerator.save_state(save_path)
                        logger.info(f'Saved state to {save_path}')
            logs = {'loss': loss.detach().item(), 'lr': lr_scheduler.get_last_lr()[0]}
            progress_bar.set_postfix(**logs)
            accelerator.log(logs, step=global_step)
            if global_step >= args.max_train_steps:
                break
        if accelerator.is_main_process:
            if args.validation_prompt is not None and epoch % args.validation_epochs == 0:
                pipeline = DiffusionPipeline.from_pretrained(args.pretrained_model_name_or_path, unet=unwrap_model(unet), text_encoder=None if args.pre_compute_text_embeddings else unwrap_model(text_encoder), revision=args.revision, variant=args.variant, torch_dtype=weight_dtype)
                if args.pre_compute_text_embeddings:
                    pipeline_args = {'prompt_embeds': validation_prompt_encoder_hidden_states, 'negative_prompt_embeds': validation_prompt_negative_prompt_embeds}
                else:
                    pipeline_args = {'prompt': args.validation_prompt}
                images = log_validation(pipeline, args, accelerator, pipeline_args, epoch)
    accelerator.wait_for_everyone()
    if accelerator.is_main_process:
        unet = unwrap_model(unet)
        unet = unet.to(torch.float32)
        unet_lora_state_dict = convert_state_dict_to_diffusers(get_peft_model_state_dict(unet))
        if args.train_text_encoder:
            text_encoder = unwrap_model(text_encoder)
            text_encoder_state_dict = convert_state_dict_to_diffusers(get_peft_model_state_dict(text_encoder))
        else:
            text_encoder_state_dict = None
        LoraLoaderMixin.save_lora_weights(save_directory=args.output_dir, unet_lora_layers=unet_lora_state_dict, text_encoder_lora_layers=text_encoder_state_dict)
    accelerator.end_training()

# File: autotrain-advanced-main/src/autotrain/trainers/dreambooth/train_xl.py
import contextlib
import gc
import itertools
import json
import logging
import math
import os
import random
import shutil
from pathlib import Path
import diffusers
import numpy as np
import torch
import torch.nn.functional as F
import torch.utils.checkpoint
import transformers
from accelerate import Accelerator
from accelerate.utils import DistributedDataParallelKwargs, ProjectConfiguration, set_seed
from diffusers import AutoencoderKL, DDPMScheduler, DPMSolverMultistepScheduler, EDMEulerScheduler, EulerDiscreteScheduler, StableDiffusionXLPipeline, UNet2DConditionModel
from diffusers.loaders import LoraLoaderMixin
from diffusers.optimization import get_scheduler
from diffusers.training_utils import _set_state_dict_into_text_encoder, cast_training_params, compute_snr
from diffusers.utils import convert_state_dict_to_diffusers, convert_unet_state_dict_to_peft, is_wandb_available
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.torch_utils import is_compiled_module
from huggingface_hub import hf_hub_download
from huggingface_hub.utils import insecure_hashlib
from packaging import version
from peft import LoraConfig, set_peft_model_state_dict
from peft.utils import get_peft_model_state_dict
from PIL import Image
from PIL.ImageOps import exif_transpose
from torch.utils.data import Dataset
from torchvision import transforms
from torchvision.transforms.functional import crop
from tqdm.auto import tqdm
from transformers import AutoTokenizer, PretrainedConfig
from autotrain import logger

def determine_scheduler_type(pretrained_model_name_or_path, revision):
    model_index_filename = 'model_index.json'
    if os.path.isdir(pretrained_model_name_or_path):
        model_index = os.path.join(pretrained_model_name_or_path, model_index_filename)
    else:
        model_index = hf_hub_download(repo_id=pretrained_model_name_or_path, filename=model_index_filename, revision=revision)
    with open(model_index, 'r') as f:
        scheduler_type = json.load(f)['scheduler'][1]
    return scheduler_type

def log_validation(pipeline, args, accelerator, pipeline_args, epoch, is_final_validation=False):
    logger.info(f'Running validation... \n Generating {args.num_validation_images} images with prompt: {args.validation_prompt}.')
    scheduler_args = {}
    if not args.do_edm_style_training:
        if 'variance_type' in pipeline.scheduler.config:
            variance_type = pipeline.scheduler.config.variance_type
            if variance_type in ['learned', 'learned_range']:
                variance_type = 'fixed_small'
            scheduler_args['variance_type'] = variance_type
        pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config, **scheduler_args)
    pipeline = pipeline.to(accelerator.device)
    pipeline.set_progress_bar_config(disable=True)
    generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) if args.seed else None
    inference_ctx = contextlib.nullcontext() if 'playground' in args.pretrained_model_name_or_path else torch.cuda.amp.autocast()
    with inference_ctx:
        images = [pipeline(**pipeline_args, generator=generator).images[0] for _ in range(args.num_validation_images)]
    for tracker in accelerator.trackers:
        phase_name = 'test' if is_final_validation else 'validation'
        if tracker.name == 'tensorboard':
            np_images = np.stack([np.asarray(img) for img in images])
            tracker.writer.add_images(phase_name, np_images, epoch, dataformats='NHWC')
    del pipeline
    torch.cuda.empty_cache()
    return images

def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str, subfolder: str='text_encoder'):
    text_encoder_config = PretrainedConfig.from_pretrained(pretrained_model_name_or_path, subfolder=subfolder, revision=revision)
    model_class = text_encoder_config.architectures[0]
    if model_class == 'CLIPTextModel':
        from transformers import CLIPTextModel
        return CLIPTextModel
    elif model_class == 'CLIPTextModelWithProjection':
        from transformers import CLIPTextModelWithProjection
        return CLIPTextModelWithProjection
    else:
        raise ValueError(f'{model_class} is not supported.')

class DreamBoothDataset(Dataset):

    def __init__(self, instance_data_root, instance_prompt, class_prompt, class_data_root=None, class_num=None, size=1024, repeats=1, center_crop=False, random_flip=False):
        self.size = size
        self.resolution = size
        self.center_crop = center_crop
        self.instance_prompt = instance_prompt
        self.custom_instance_prompts = None
        self.class_prompt = class_prompt
        self.random_flip = random_flip
        self.instance_data_root = Path(instance_data_root)
        if not self.instance_data_root.exists():
            raise ValueError("Instance images root doesn't exists.")
        instance_images = [Image.open(path) for path in list(Path(instance_data_root).iterdir())]
        self.custom_instance_prompts = None
        self.instance_images = []
        for img in instance_images:
            self.instance_images.extend(itertools.repeat(img, repeats))
        self.original_sizes = []
        self.crop_top_lefts = []
        self.pixel_values = []
        train_resize = transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR)
        train_crop = transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size)
        train_flip = transforms.RandomHorizontalFlip(p=1.0)
        train_transforms = transforms.Compose([transforms.ToTensor(), transforms.Normalize([0.5], [0.5])])
        for image in self.instance_images:
            image = exif_transpose(image)
            if not image.mode == 'RGB':
                image = image.convert('RGB')
            self.original_sizes.append((image.height, image.width))
            image = train_resize(image)
            if self.random_flip and random.random() < 0.5:
                image = train_flip(image)
            if self.center_crop:
                y1 = max(0, int(round((image.height - self.resolution) / 2.0)))
                x1 = max(0, int(round((image.width - self.resolution) / 2.0)))
                image = train_crop(image)
            else:
                (y1, x1, h, w) = train_crop.get_params(image, (self.resolution, self.resolution))
                image = crop(image, y1, x1, h, w)
            crop_top_left = (y1, x1)
            self.crop_top_lefts.append(crop_top_left)
            image = train_transforms(image)
            self.pixel_values.append(image)
        self.num_instance_images = len(self.instance_images)
        self._length = self.num_instance_images
        if class_data_root is not None:
            self.class_data_root = Path(class_data_root)
            self.class_data_root.mkdir(parents=True, exist_ok=True)
            self.class_images_path = list(self.class_data_root.iterdir())
            if class_num is not None:
                self.num_class_images = min(len(self.class_images_path), class_num)
            else:
                self.num_class_images = len(self.class_images_path)
            self._length = max(self.num_class_images, self.num_instance_images)
        else:
            self.class_data_root = None
        self.image_transforms = transforms.Compose([transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])])

    def __len__(self):
        return self._length

    def __getitem__(self, index):
        example = {}
        instance_image = self.pixel_values[index % self.num_instance_images]
        original_size = self.original_sizes[index % self.num_instance_images]
        crop_top_left = self.crop_top_lefts[index % self.num_instance_images]
        example['instance_images'] = instance_image
        example['original_size'] = original_size
        example['crop_top_left'] = crop_top_left
        if self.custom_instance_prompts:
            caption = self.custom_instance_prompts[index % self.num_instance_images]
            if caption:
                example['instance_prompt'] = caption
            else:
                example['instance_prompt'] = self.instance_prompt
        else:
            example['instance_prompt'] = self.instance_prompt
        if self.class_data_root:
            class_image = Image.open(self.class_images_path[index % self.num_class_images])
            class_image = exif_transpose(class_image)
            if not class_image.mode == 'RGB':
                class_image = class_image.convert('RGB')
            example['class_images'] = self.image_transforms(class_image)
            example['class_prompt'] = self.class_prompt
        return example

def collate_fn(examples, with_prior_preservation=False):
    pixel_values = [example['instance_images'] for example in examples]
    prompts = [example['instance_prompt'] for example in examples]
    original_sizes = [example['original_size'] for example in examples]
    crop_top_lefts = [example['crop_top_left'] for example in examples]
    if with_prior_preservation:
        pixel_values += [example['class_images'] for example in examples]
        prompts += [example['class_prompt'] for example in examples]
        original_sizes += [example['original_size'] for example in examples]
        crop_top_lefts += [example['crop_top_left'] for example in examples]
    pixel_values = torch.stack(pixel_values)
    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
    batch = {'pixel_values': pixel_values, 'prompts': prompts, 'original_sizes': original_sizes, 'crop_top_lefts': crop_top_lefts}
    return batch

class PromptDataset(Dataset):

    def __init__(self, prompt, num_samples):
        self.prompt = prompt
        self.num_samples = num_samples

    def __len__(self):
        return self.num_samples

    def __getitem__(self, index):
        example = {}
        example['prompt'] = self.prompt
        example['index'] = index
        return example

def tokenize_prompt(tokenizer, prompt):
    text_inputs = tokenizer(prompt, padding='max_length', max_length=tokenizer.model_max_length, truncation=True, return_tensors='pt')
    text_input_ids = text_inputs.input_ids
    return text_input_ids

def encode_prompt(text_encoders, tokenizers, prompt, text_input_ids_list=None):
    prompt_embeds_list = []
    for (i, text_encoder) in enumerate(text_encoders):
        if tokenizers is not None:
            tokenizer = tokenizers[i]
            text_input_ids = tokenize_prompt(tokenizer, prompt)
        else:
            assert text_input_ids_list is not None
            text_input_ids = text_input_ids_list[i]
        prompt_embeds = text_encoder(text_input_ids.to(text_encoder.device), output_hidden_states=True, return_dict=False)
        pooled_prompt_embeds = prompt_embeds[0]
        prompt_embeds = prompt_embeds[-1][-2]
        (bs_embed, seq_len, _) = prompt_embeds.shape
        prompt_embeds = prompt_embeds.view(bs_embed, seq_len, -1)
        prompt_embeds_list.append(prompt_embeds)
    prompt_embeds = torch.concat(prompt_embeds_list, dim=-1)
    pooled_prompt_embeds = pooled_prompt_embeds.view(bs_embed, -1)
    return (prompt_embeds, pooled_prompt_embeds)

def main(args):
    if args.report_to == 'wandb' and args.hub_token is not None:
        raise ValueError('You cannot use both --report_to=wandb and --hub_token due to a security risk of exposing your token. Please use `huggingface-cli login` to authenticate with the Hub.')
    if args.do_edm_style_training and args.snr_gamma is not None:
        raise ValueError('Min-SNR formulation is not supported when conducting EDM-style training.')
    logging_dir = Path(args.output_dir, args.logging_dir)
    accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir)
    kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
    accelerator = Accelerator(gradient_accumulation_steps=args.gradient_accumulation_steps, mixed_precision=args.mixed_precision, log_with=args.report_to, project_config=accelerator_project_config, kwargs_handlers=[kwargs])
    if args.report_to == 'wandb':
        if not is_wandb_available():
            raise ImportError('Make sure to install wandb if you want to use it for logging during training.')
    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO)
    if accelerator.is_local_main_process:
        transformers.utils.logging.set_verbosity_warning()
        diffusers.utils.logging.set_verbosity_info()
    else:
        transformers.utils.logging.set_verbosity_error()
        diffusers.utils.logging.set_verbosity_error()
    if args.seed is not None:
        set_seed(args.seed)
    if args.with_prior_preservation:
        class_images_dir = Path(args.class_data_dir)
        if not class_images_dir.exists():
            class_images_dir.mkdir(parents=True)
        cur_class_images = len(list(class_images_dir.iterdir()))
        if cur_class_images < args.num_class_images:
            torch_dtype = torch.float16 if accelerator.device.type == 'cuda' else torch.float32
            if args.prior_generation_precision == 'fp32':
                torch_dtype = torch.float32
            elif args.prior_generation_precision == 'fp16':
                torch_dtype = torch.float16
            elif args.prior_generation_precision == 'bf16':
                torch_dtype = torch.bfloat16
            pipeline = StableDiffusionXLPipeline.from_pretrained(args.pretrained_model_name_or_path, torch_dtype=torch_dtype, revision=args.revision, variant=args.variant)
            pipeline.set_progress_bar_config(disable=True)
            num_new_images = args.num_class_images - cur_class_images
            logger.info(f'Number of class images to sample: {num_new_images}.')
            sample_dataset = PromptDataset(args.class_prompt, num_new_images)
            sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
            sample_dataloader = accelerator.prepare(sample_dataloader)
            pipeline.to(accelerator.device)
            for example in tqdm(sample_dataloader, desc='Generating class images', disable=not accelerator.is_local_main_process):
                images = pipeline(example['prompt']).images
                for (i, image) in enumerate(images):
                    hash_image = insecure_hashlib.sha1(image.tobytes()).hexdigest()
                    image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg"
                    image.save(image_filename)
            del pipeline
            if torch.cuda.is_available():
                torch.cuda.empty_cache()
    if accelerator.is_main_process:
        if args.output_dir is not None:
            os.makedirs(args.output_dir, exist_ok=True)
    tokenizer_one = AutoTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder='tokenizer', revision=args.revision, use_fast=False)
    tokenizer_two = AutoTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder='tokenizer_2', revision=args.revision, use_fast=False)
    text_encoder_cls_one = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
    text_encoder_cls_two = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision, subfolder='text_encoder_2')
    scheduler_type = determine_scheduler_type(args.pretrained_model_name_or_path, args.revision)
    if 'EDM' in scheduler_type:
        args.do_edm_style_training = True
        noise_scheduler = EDMEulerScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder='scheduler')
        logger.info('Performing EDM-style training!')
    elif args.do_edm_style_training:
        noise_scheduler = EulerDiscreteScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder='scheduler')
        logger.info('Performing EDM-style training!')
    else:
        noise_scheduler = DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder='scheduler')
    text_encoder_one = text_encoder_cls_one.from_pretrained(args.pretrained_model_name_or_path, subfolder='text_encoder', revision=args.revision, variant=args.variant)
    text_encoder_two = text_encoder_cls_two.from_pretrained(args.pretrained_model_name_or_path, subfolder='text_encoder_2', revision=args.revision, variant=args.variant)
    vae_path = args.pretrained_model_name_or_path if args.pretrained_vae_model_name_or_path is None else args.pretrained_vae_model_name_or_path
    vae = AutoencoderKL.from_pretrained(vae_path, subfolder='vae' if args.pretrained_vae_model_name_or_path is None else None, revision=args.revision, variant=args.variant)
    latents_mean = latents_std = None
    if hasattr(vae.config, 'latents_mean') and vae.config.latents_mean is not None:
        latents_mean = torch.tensor(vae.config.latents_mean).view(1, 4, 1, 1)
    if hasattr(vae.config, 'latents_std') and vae.config.latents_std is not None:
        latents_std = torch.tensor(vae.config.latents_std).view(1, 4, 1, 1)
    unet = UNet2DConditionModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='unet', revision=args.revision, variant=args.variant)
    vae.requires_grad_(False)
    text_encoder_one.requires_grad_(False)
    text_encoder_two.requires_grad_(False)
    unet.requires_grad_(False)
    weight_dtype = torch.float32
    if accelerator.mixed_precision == 'fp16':
        weight_dtype = torch.float16
    elif accelerator.mixed_precision == 'bf16':
        weight_dtype = torch.bfloat16
    unet.to(accelerator.device, dtype=weight_dtype)
    vae.to(accelerator.device, dtype=torch.float32)
    text_encoder_one.to(accelerator.device, dtype=weight_dtype)
    text_encoder_two.to(accelerator.device, dtype=weight_dtype)
    if args.enable_xformers_memory_efficient_attention:
        if is_xformers_available():
            import xformers
            xformers_version = version.parse(xformers.__version__)
            if xformers_version == version.parse('0.0.16'):
                logger.warning('xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details.')
            unet.enable_xformers_memory_efficient_attention()
        else:
            raise ValueError('xformers is not available. Make sure it is installed correctly')
    if args.gradient_checkpointing:
        unet.enable_gradient_checkpointing()
        if args.train_text_encoder:
            text_encoder_one.gradient_checkpointing_enable()
            text_encoder_two.gradient_checkpointing_enable()
    unet_lora_config = LoraConfig(r=args.rank, use_dora=args.use_dora, lora_alpha=args.rank, init_lora_weights='gaussian', target_modules=['to_k', 'to_q', 'to_v', 'to_out.0'])
    unet.add_adapter(unet_lora_config)
    if args.train_text_encoder:
        text_lora_config = LoraConfig(r=args.rank, use_dora=args.use_dora, lora_alpha=args.rank, init_lora_weights='gaussian', target_modules=['q_proj', 'k_proj', 'v_proj', 'out_proj'])
        text_encoder_one.add_adapter(text_lora_config)
        text_encoder_two.add_adapter(text_lora_config)

    def unwrap_model(model):
        model = accelerator.unwrap_model(model)
        model = model._orig_mod if is_compiled_module(model) else model
        return model

    def save_model_hook(models, weights, output_dir):
        if accelerator.is_main_process:
            unet_lora_layers_to_save = None
            text_encoder_one_lora_layers_to_save = None
            text_encoder_two_lora_layers_to_save = None
            for model in models:
                if isinstance(model, type(unwrap_model(unet))):
                    unet_lora_layers_to_save = convert_state_dict_to_diffusers(get_peft_model_state_dict(model))
                elif isinstance(model, type(unwrap_model(text_encoder_one))):
                    text_encoder_one_lora_layers_to_save = convert_state_dict_to_diffusers(get_peft_model_state_dict(model))
                elif isinstance(model, type(unwrap_model(text_encoder_two))):
                    text_encoder_two_lora_layers_to_save = convert_state_dict_to_diffusers(get_peft_model_state_dict(model))
                else:
                    raise ValueError(f'unexpected save model: {model.__class__}')
                weights.pop()
            StableDiffusionXLPipeline.save_lora_weights(output_dir, unet_lora_layers=unet_lora_layers_to_save, text_encoder_lora_layers=text_encoder_one_lora_layers_to_save, text_encoder_2_lora_layers=text_encoder_two_lora_layers_to_save)

    def load_model_hook(models, input_dir):
        unet_ = None
        text_encoder_one_ = None
        text_encoder_two_ = None
        while len(models) > 0:
            model = models.pop()
            if isinstance(model, type(unwrap_model(unet))):
                unet_ = model
            elif isinstance(model, type(unwrap_model(text_encoder_one))):
                text_encoder_one_ = model
            elif isinstance(model, type(unwrap_model(text_encoder_two))):
                text_encoder_two_ = model
            else:
                raise ValueError(f'unexpected save model: {model.__class__}')
        (lora_state_dict, network_alphas) = LoraLoaderMixin.lora_state_dict(input_dir)
        unet_state_dict = {f"{k.replace('unet.', '')}": v for (k, v) in lora_state_dict.items() if k.startswith('unet.')}
        unet_state_dict = convert_unet_state_dict_to_peft(unet_state_dict)
        incompatible_keys = set_peft_model_state_dict(unet_, unet_state_dict, adapter_name='default')
        if incompatible_keys is not None:
            unexpected_keys = getattr(incompatible_keys, 'unexpected_keys', None)
            if unexpected_keys:
                logger.warning(f'Loading adapter weights from state_dict led to unexpected keys not found in the model:  {unexpected_keys}. ')
        if args.train_text_encoder:
            _set_state_dict_into_text_encoder(lora_state_dict, prefix='text_encoder.', text_encoder=text_encoder_one_)
            _set_state_dict_into_text_encoder(lora_state_dict, prefix='text_encoder_2.', text_encoder=text_encoder_two_)
        if args.mixed_precision == 'fp16':
            models = [unet_]
            if args.train_text_encoder:
                models.extend([text_encoder_one_, text_encoder_two_])
                cast_training_params(models)
    accelerator.register_save_state_pre_hook(save_model_hook)
    accelerator.register_load_state_pre_hook(load_model_hook)
    if args.allow_tf32:
        torch.backends.cuda.matmul.allow_tf32 = True
    if args.scale_lr:
        args.learning_rate = args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
    if args.mixed_precision == 'fp16':
        models = [unet]
        if args.train_text_encoder:
            models.extend([text_encoder_one, text_encoder_two])
        cast_training_params(models, dtype=torch.float32)
    unet_lora_parameters = list(filter(lambda p: p.requires_grad, unet.parameters()))
    if args.train_text_encoder:
        text_lora_parameters_one = list(filter(lambda p: p.requires_grad, text_encoder_one.parameters()))
        text_lora_parameters_two = list(filter(lambda p: p.requires_grad, text_encoder_two.parameters()))
    unet_lora_parameters_with_lr = {'params': unet_lora_parameters, 'lr': args.learning_rate}
    if args.train_text_encoder:
        text_lora_parameters_one_with_lr = {'params': text_lora_parameters_one, 'weight_decay': args.adam_weight_decay_text_encoder, 'lr': args.text_encoder_lr if args.text_encoder_lr else args.learning_rate}
        text_lora_parameters_two_with_lr = {'params': text_lora_parameters_two, 'weight_decay': args.adam_weight_decay_text_encoder, 'lr': args.text_encoder_lr if args.text_encoder_lr else args.learning_rate}
        params_to_optimize = [unet_lora_parameters_with_lr, text_lora_parameters_one_with_lr, text_lora_parameters_two_with_lr]
    else:
        params_to_optimize = [unet_lora_parameters_with_lr]
    if not (args.optimizer.lower() == 'prodigy' or args.optimizer.lower() == 'adamw'):
        logger.warning(f'Unsupported choice of optimizer: {args.optimizer}.Supported optimizers include [adamW, prodigy].Defaulting to adamW')
        args.optimizer = 'adamw'
    if args.use_8bit_adam and (not args.optimizer.lower() == 'adamw'):
        logger.warning(f"use_8bit_adam is ignored when optimizer is not set to 'AdamW'. Optimizer was set to {args.optimizer.lower()}")
    if args.optimizer.lower() == 'adamw':
        if args.use_8bit_adam:
            try:
                import bitsandbytes as bnb
            except ImportError:
                raise ImportError('To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`.')
            optimizer_class = bnb.optim.AdamW8bit
        else:
            optimizer_class = torch.optim.AdamW
        optimizer = optimizer_class(params_to_optimize, betas=(args.adam_beta1, args.adam_beta2), weight_decay=args.adam_weight_decay, eps=args.adam_epsilon)
    if args.optimizer.lower() == 'prodigy':
        try:
            import prodigyopt
        except ImportError:
            raise ImportError('To use Prodigy, please install the prodigyopt library: `pip install prodigyopt`')
        optimizer_class = prodigyopt.Prodigy
        if args.learning_rate <= 0.1:
            logger.warning("Learning rate is too low. When using prodigy, it's generally better to set learning rate around 1.0")
        if args.train_text_encoder and args.text_encoder_lr:
            logger.warning(f'Learning rates were provided both for the unet and the text encoder- e.g. text_encoder_lr: {args.text_encoder_lr} and learning_rate: {args.learning_rate}. When using prodigy only learning_rate is used as the initial learning rate.')
            params_to_optimize[1]['lr'] = args.learning_rate
            params_to_optimize[2]['lr'] = args.learning_rate
        optimizer = optimizer_class(params_to_optimize, lr=args.learning_rate, betas=(args.adam_beta1, args.adam_beta2), beta3=args.prodigy_beta3, weight_decay=args.adam_weight_decay, eps=args.adam_epsilon, decouple=args.prodigy_decouple, use_bias_correction=args.prodigy_use_bias_correction, safeguard_warmup=args.prodigy_safeguard_warmup)
    train_dataset = DreamBoothDataset(instance_data_root=args.instance_data_dir, instance_prompt=args.instance_prompt, class_prompt=args.class_prompt, class_data_root=args.class_data_dir if args.with_prior_preservation else None, class_num=args.num_class_images, size=args.resolution, repeats=args.repeats, center_crop=args.center_crop, random_flip=args.random_flip)
    train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=args.train_batch_size, shuffle=True, collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation), num_workers=args.dataloader_num_workers)

    def compute_time_ids(original_size, crops_coords_top_left):
        target_size = (args.resolution, args.resolution)
        add_time_ids = list(original_size + crops_coords_top_left + target_size)
        add_time_ids = torch.tensor([add_time_ids])
        add_time_ids = add_time_ids.to(accelerator.device, dtype=weight_dtype)
        return add_time_ids
    if not args.train_text_encoder:
        tokenizers = [tokenizer_one, tokenizer_two]
        text_encoders = [text_encoder_one, text_encoder_two]

        def compute_text_embeddings(prompt, text_encoders, tokenizers):
            with torch.no_grad():
                (prompt_embeds, pooled_prompt_embeds) = encode_prompt(text_encoders, tokenizers, prompt)
                prompt_embeds = prompt_embeds.to(accelerator.device)
                pooled_prompt_embeds = pooled_prompt_embeds.to(accelerator.device)
            return (prompt_embeds, pooled_prompt_embeds)
    if not args.train_text_encoder and (not train_dataset.custom_instance_prompts):
        (instance_prompt_hidden_states, instance_pooled_prompt_embeds) = compute_text_embeddings(args.instance_prompt, text_encoders, tokenizers)
    if args.with_prior_preservation:
        if not args.train_text_encoder:
            (class_prompt_hidden_states, class_pooled_prompt_embeds) = compute_text_embeddings(args.class_prompt, text_encoders, tokenizers)
    if not args.train_text_encoder and (not train_dataset.custom_instance_prompts):
        del tokenizers, text_encoders
        gc.collect()
        torch.cuda.empty_cache()
    if not train_dataset.custom_instance_prompts:
        if not args.train_text_encoder:
            prompt_embeds = instance_prompt_hidden_states
            unet_add_text_embeds = instance_pooled_prompt_embeds
            if args.with_prior_preservation:
                prompt_embeds = torch.cat([prompt_embeds, class_prompt_hidden_states], dim=0)
                unet_add_text_embeds = torch.cat([unet_add_text_embeds, class_pooled_prompt_embeds], dim=0)
        else:
            tokens_one = tokenize_prompt(tokenizer_one, args.instance_prompt)
            tokens_two = tokenize_prompt(tokenizer_two, args.instance_prompt)
            if args.with_prior_preservation:
                class_tokens_one = tokenize_prompt(tokenizer_one, args.class_prompt)
                class_tokens_two = tokenize_prompt(tokenizer_two, args.class_prompt)
                tokens_one = torch.cat([tokens_one, class_tokens_one], dim=0)
                tokens_two = torch.cat([tokens_two, class_tokens_two], dim=0)
    overrode_max_train_steps = False
    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
    if args.max_train_steps is None:
        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
        overrode_max_train_steps = True
    lr_scheduler = get_scheduler(args.lr_scheduler, optimizer=optimizer, num_warmup_steps=args.lr_warmup_steps * accelerator.num_processes, num_training_steps=args.max_train_steps * accelerator.num_processes, num_cycles=args.lr_num_cycles, power=args.lr_power)
    if args.train_text_encoder:
        (unet, text_encoder_one, text_encoder_two, optimizer, train_dataloader, lr_scheduler) = accelerator.prepare(unet, text_encoder_one, text_encoder_two, optimizer, train_dataloader, lr_scheduler)
    else:
        (unet, optimizer, train_dataloader, lr_scheduler) = accelerator.prepare(unet, optimizer, train_dataloader, lr_scheduler)
    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
    if overrode_max_train_steps:
        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
    if accelerator.is_main_process:
        tracker_name = 'dreambooth-lora-sd-xl' if 'playground' not in args.pretrained_model_name_or_path else 'dreambooth-lora-playground'
        accelerator.init_trackers(tracker_name, config=vars(args))
    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
    logger.info('***** Running training *****')
    logger.info(f'  Num examples = {len(train_dataset)}')
    logger.info(f'  Num batches each epoch = {len(train_dataloader)}')
    logger.info(f'  Num Epochs = {args.num_train_epochs}')
    logger.info(f'  Instantaneous batch size per device = {args.train_batch_size}')
    logger.info(f'  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}')
    logger.info(f'  Gradient Accumulation steps = {args.gradient_accumulation_steps}')
    logger.info(f'  Total optimization steps = {args.max_train_steps}')
    global_step = 0
    first_epoch = 0
    if args.resume_from_checkpoint:
        if args.resume_from_checkpoint != 'latest':
            path = os.path.basename(args.resume_from_checkpoint)
        else:
            dirs = os.listdir(args.output_dir)
            dirs = [d for d in dirs if d.startswith('checkpoint')]
            dirs = sorted(dirs, key=lambda x: int(x.split('-')[1]))
            path = dirs[-1] if len(dirs) > 0 else None
        if path is None:
            accelerator.print(f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run.")
            args.resume_from_checkpoint = None
            initial_global_step = 0
        else:
            accelerator.print(f'Resuming from checkpoint {path}')
            accelerator.load_state(os.path.join(args.output_dir, path))
            global_step = int(path.split('-')[1])
            initial_global_step = global_step
            first_epoch = global_step // num_update_steps_per_epoch
    else:
        initial_global_step = 0
    progress_bar = tqdm(range(0, args.max_train_steps), initial=initial_global_step, desc='Steps', disable=not accelerator.is_local_main_process)

    def get_sigmas(timesteps, n_dim=4, dtype=torch.float32):
        sigmas = noise_scheduler.sigmas.to(device=accelerator.device, dtype=dtype)
        schedule_timesteps = noise_scheduler.timesteps.to(accelerator.device)
        timesteps = timesteps.to(accelerator.device)
        step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps]
        sigma = sigmas[step_indices].flatten()
        while len(sigma.shape) < n_dim:
            sigma = sigma.unsqueeze(-1)
        return sigma
    for epoch in range(first_epoch, args.num_train_epochs):
        unet.train()
        if args.train_text_encoder:
            text_encoder_one.train()
            text_encoder_two.train()
            accelerator.unwrap_model(text_encoder_one).text_model.embeddings.requires_grad_(True)
            accelerator.unwrap_model(text_encoder_two).text_model.embeddings.requires_grad_(True)
        for (step, batch) in enumerate(train_dataloader):
            with accelerator.accumulate(unet):
                pixel_values = batch['pixel_values'].to(dtype=vae.dtype)
                prompts = batch['prompts']
                if train_dataset.custom_instance_prompts:
                    if not args.train_text_encoder:
                        (prompt_embeds, unet_add_text_embeds) = compute_text_embeddings(prompts, text_encoders, tokenizers)
                    else:
                        tokens_one = tokenize_prompt(tokenizer_one, prompts)
                        tokens_two = tokenize_prompt(tokenizer_two, prompts)
                model_input = vae.encode(pixel_values).latent_dist.sample()
                if latents_mean is None and latents_std is None:
                    model_input = model_input * vae.config.scaling_factor
                    if args.pretrained_vae_model_name_or_path is None:
                        model_input = model_input.to(weight_dtype)
                else:
                    latents_mean = latents_mean.to(device=model_input.device, dtype=model_input.dtype)
                    latents_std = latents_std.to(device=model_input.device, dtype=model_input.dtype)
                    model_input = (model_input - latents_mean) * vae.config.scaling_factor / latents_std
                    model_input = model_input.to(dtype=weight_dtype)
                noise = torch.randn_like(model_input)
                bsz = model_input.shape[0]
                if not args.do_edm_style_training:
                    timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=model_input.device)
                    timesteps = timesteps.long()
                else:
                    indices = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,))
                    timesteps = noise_scheduler.timesteps[indices].to(device=model_input.device)
                noisy_model_input = noise_scheduler.add_noise(model_input, noise, timesteps)
                if args.do_edm_style_training:
                    sigmas = get_sigmas(timesteps, len(noisy_model_input.shape), noisy_model_input.dtype)
                    if 'EDM' in scheduler_type:
                        inp_noisy_latents = noise_scheduler.precondition_inputs(noisy_model_input, sigmas)
                    else:
                        inp_noisy_latents = noisy_model_input / (sigmas ** 2 + 1) ** 0.5
                add_time_ids = torch.cat([compute_time_ids(original_size=s, crops_coords_top_left=c) for (s, c) in zip(batch['original_sizes'], batch['crop_top_lefts'])])
                if not train_dataset.custom_instance_prompts:
                    elems_to_repeat_text_embeds = bsz // 2 if args.with_prior_preservation else bsz
                else:
                    elems_to_repeat_text_embeds = 1
                if not args.train_text_encoder:
                    unet_added_conditions = {'time_ids': add_time_ids, 'text_embeds': unet_add_text_embeds.repeat(elems_to_repeat_text_embeds, 1)}
                    prompt_embeds_input = prompt_embeds.repeat(elems_to_repeat_text_embeds, 1, 1)
                    model_pred = unet(inp_noisy_latents if args.do_edm_style_training else noisy_model_input, timesteps, prompt_embeds_input, added_cond_kwargs=unet_added_conditions, return_dict=False)[0]
                else:
                    unet_added_conditions = {'time_ids': add_time_ids}
                    (prompt_embeds, pooled_prompt_embeds) = encode_prompt(text_encoders=[text_encoder_one, text_encoder_two], tokenizers=None, prompt=None, text_input_ids_list=[tokens_one, tokens_two])
                    unet_added_conditions.update({'text_embeds': pooled_prompt_embeds.repeat(elems_to_repeat_text_embeds, 1)})
                    prompt_embeds_input = prompt_embeds.repeat(elems_to_repeat_text_embeds, 1, 1)
                    model_pred = unet(inp_noisy_latents if args.do_edm_style_training else noisy_model_input, timesteps, prompt_embeds_input, added_cond_kwargs=unet_added_conditions, return_dict=False)[0]
                weighting = None
                if args.do_edm_style_training:
                    if 'EDM' in scheduler_type:
                        model_pred = noise_scheduler.precondition_outputs(noisy_model_input, model_pred, sigmas)
                    elif noise_scheduler.config.prediction_type == 'epsilon':
                        model_pred = model_pred * -sigmas + noisy_model_input
                    elif noise_scheduler.config.prediction_type == 'v_prediction':
                        model_pred = model_pred * (-sigmas / (sigmas ** 2 + 1) ** 0.5) + noisy_model_input / (sigmas ** 2 + 1)
                    if 'EDM' not in scheduler_type:
                        weighting = (sigmas ** (-2.0)).float()
                if noise_scheduler.config.prediction_type == 'epsilon':
                    target = model_input if args.do_edm_style_training else noise
                elif noise_scheduler.config.prediction_type == 'v_prediction':
                    target = model_input if args.do_edm_style_training else noise_scheduler.get_velocity(model_input, noise, timesteps)
                else:
                    raise ValueError(f'Unknown prediction type {noise_scheduler.config.prediction_type}')
                if args.with_prior_preservation:
                    (model_pred, model_pred_prior) = torch.chunk(model_pred, 2, dim=0)
                    (target, target_prior) = torch.chunk(target, 2, dim=0)
                    if weighting is not None:
                        prior_loss = torch.mean((weighting.float() * (model_pred_prior.float() - target_prior.float()) ** 2).reshape(target_prior.shape[0], -1), 1)
                        prior_loss = prior_loss.mean()
                    else:
                        prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction='mean')
                if args.snr_gamma is None:
                    if weighting is not None:
                        loss = torch.mean((weighting.float() * (model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1), 1)
                        loss = loss.mean()
                    else:
                        loss = F.mse_loss(model_pred.float(), target.float(), reduction='mean')
                else:
                    snr = compute_snr(noise_scheduler, timesteps)
                    base_weight = torch.stack([snr, args.snr_gamma * torch.ones_like(timesteps)], dim=1).min(dim=1)[0] / snr
                    if noise_scheduler.config.prediction_type == 'v_prediction':
                        mse_loss_weights = base_weight + 1
                    else:
                        mse_loss_weights = base_weight
                    loss = F.mse_loss(model_pred.float(), target.float(), reduction='none')
                    loss = loss.mean(dim=list(range(1, len(loss.shape)))) * mse_loss_weights
                    loss = loss.mean()
                if args.with_prior_preservation:
                    loss = loss + args.prior_loss_weight * prior_loss
                accelerator.backward(loss)
                if accelerator.sync_gradients:
                    params_to_clip = itertools.chain(unet_lora_parameters, text_lora_parameters_one, text_lora_parameters_two) if args.train_text_encoder else unet_lora_parameters
                    accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
                optimizer.step()
                lr_scheduler.step()
                optimizer.zero_grad()
            if accelerator.sync_gradients:
                progress_bar.update(1)
                global_step += 1
                if accelerator.is_main_process:
                    if global_step % args.checkpointing_steps == 0:
                        if args.checkpoints_total_limit is not None:
                            checkpoints = os.listdir(args.output_dir)
                            checkpoints = [d for d in checkpoints if d.startswith('checkpoint')]
                            checkpoints = sorted(checkpoints, key=lambda x: int(x.split('-')[1]))
                            if len(checkpoints) >= args.checkpoints_total_limit:
                                num_to_remove = len(checkpoints) - args.checkpoints_total_limit + 1
                                removing_checkpoints = checkpoints[0:num_to_remove]
                                logger.info(f'{len(checkpoints)} checkpoints already exist, removing {len(removing_checkpoints)} checkpoints')
                                logger.info(f"removing checkpoints: {', '.join(removing_checkpoints)}")
                                for removing_checkpoint in removing_checkpoints:
                                    removing_checkpoint = os.path.join(args.output_dir, removing_checkpoint)
                                    shutil.rmtree(removing_checkpoint)
                        save_path = os.path.join(args.output_dir, f'checkpoint-{global_step}')
                        accelerator.save_state(save_path)
                        logger.info(f'Saved state to {save_path}')
            logs = {'loss': loss.detach().item(), 'lr': lr_scheduler.get_last_lr()[0]}
            progress_bar.set_postfix(**logs)
            accelerator.log(logs, step=global_step)
            if global_step >= args.max_train_steps:
                break
        if accelerator.is_main_process:
            if args.validation_prompt is not None and epoch % args.validation_epochs == 0:
                if not args.train_text_encoder:
                    text_encoder_one = text_encoder_cls_one.from_pretrained(args.pretrained_model_name_or_path, subfolder='text_encoder', revision=args.revision, variant=args.variant)
                    text_encoder_two = text_encoder_cls_two.from_pretrained(args.pretrained_model_name_or_path, subfolder='text_encoder_2', revision=args.revision, variant=args.variant)
                pipeline = StableDiffusionXLPipeline.from_pretrained(args.pretrained_model_name_or_path, vae=vae, text_encoder=accelerator.unwrap_model(text_encoder_one), text_encoder_2=accelerator.unwrap_model(text_encoder_two), unet=accelerator.unwrap_model(unet), revision=args.revision, variant=args.variant, torch_dtype=weight_dtype)
                pipeline_args = {'prompt': args.validation_prompt}
                images = log_validation(pipeline, args, accelerator, pipeline_args, epoch)
    accelerator.wait_for_everyone()
    if accelerator.is_main_process:
        unet = unwrap_model(unet)
        unet = unet.to(torch.float32)
        unet_lora_layers = convert_state_dict_to_diffusers(get_peft_model_state_dict(unet))
        if args.train_text_encoder:
            text_encoder_one = unwrap_model(text_encoder_one)
            text_encoder_lora_layers = convert_state_dict_to_diffusers(get_peft_model_state_dict(text_encoder_one.to(torch.float32)))
            text_encoder_two = unwrap_model(text_encoder_two)
            text_encoder_2_lora_layers = convert_state_dict_to_diffusers(get_peft_model_state_dict(text_encoder_two.to(torch.float32)))
        else:
            text_encoder_lora_layers = None
            text_encoder_2_lora_layers = None
        StableDiffusionXLPipeline.save_lora_weights(save_directory=args.output_dir, unet_lora_layers=unet_lora_layers, text_encoder_lora_layers=text_encoder_lora_layers, text_encoder_2_lora_layers=text_encoder_2_lora_layers)
    accelerator.end_training()

# File: autotrain-advanced-main/src/autotrain/trainers/dreambooth/trainer.py
import itertools
import math
import os
import shutil
import torch
import torch.nn.functional as F
from diffusers import StableDiffusionXLPipeline
from diffusers.loaders import LoraLoaderMixin, text_encoder_lora_state_dict
from diffusers.optimization import get_scheduler
from huggingface_hub import create_repo, upload_folder
from tqdm import tqdm
from autotrain import logger
from autotrain.trainers.dreambooth import utils

class Trainer:

    def __init__(self, unet, vae, train_dataloader, train_dataset, text_encoders, config, optimizer, accelerator, noise_scheduler, weight_dtype, text_lora_parameters, unet_lora_parameters, tokenizers):
        self.train_dataloader = train_dataloader
        self.config = config
        self.optimizer = optimizer
        self.accelerator = accelerator
        self.unet = unet
        self.vae = vae
        self.noise_scheduler = noise_scheduler
        self.train_dataset = train_dataset
        self.weight_dtype = weight_dtype
        self.text_lora_parameters = text_lora_parameters
        self.unet_lora_parameters = unet_lora_parameters
        self.tokenizers = tokenizers
        self.text_encoders = text_encoders
        if self.config.xl:
            self._setup_xl()
        self.text_encoder1 = text_encoders[0]
        self.text_encoder2 = None
        if len(text_encoders) == 2:
            self.text_encoder2 = text_encoders[1]
        overrode_max_train_steps = False
        self.num_update_steps_per_epoch = math.ceil(len(train_dataloader) / config.gradient_accumulation)
        if self.config.num_steps is None:
            self.config.num_steps = self.config.epochs * self.num_update_steps_per_epoch
            overrode_max_train_steps = True
        self.scheduler = get_scheduler(self.config.scheduler, optimizer=self.optimizer, num_warmup_steps=self.config.warmup_steps * self.accelerator.num_processes, num_training_steps=self.config.num_steps * self.accelerator.num_processes, num_cycles=self.config.num_cycles, power=self.config.lr_power)
        if self.config.train_text_encoder:
            if len(text_encoders) == 1:
                (self.unet, self.text_encoder1, self.optimizer, self.train_dataloader, self.scheduler) = self.accelerator.prepare(self.unet, self.text_encoder1, self.optimizer, self.train_dataloader, self.scheduler)
            elif len(text_encoders) == 2:
                (self.unet, self.text_encoder1, self.text_encoder2, self.optimizer, self.train_dataloader, self.scheduler) = self.accelerator.prepare(self.unet, self.text_encoder1, self.text_encoder2, self.optimizer, self.train_dataloader, self.scheduler)
        else:
            (self.unet, self.optimizer, self.train_dataloader, self.scheduler) = accelerator.prepare(self.unet, self.optimizer, self.train_dataloader, self.scheduler)
        self.num_update_steps_per_epoch = math.ceil(len(self.train_dataloader) / self.config.gradient_accumulation)
        if overrode_max_train_steps:
            self.config.num_steps = self.config.epochs * self.num_update_steps_per_epoch
        self.config.epochs = math.ceil(self.config.num_steps / self.num_update_steps_per_epoch)
        if self.accelerator.is_main_process:
            self.accelerator.init_trackers('dreambooth')
        self.total_batch_size = self.config.batch_size * self.accelerator.num_processes * self.config.gradient_accumulation
        logger.info('***** Running training *****')
        logger.info(f'  Num examples = {len(self.train_dataset)}')
        logger.info(f'  Num batches each epoch = {len(self.train_dataloader)}')
        logger.info(f'  Num Epochs = {self.config.epochs}')
        logger.info(f'  Instantaneous batch size per device = {config.batch_size}')
        logger.info(f'  Total train batch size (w. parallel, distributed & accumulation) = {self.total_batch_size}')
        logger.info(f'  Gradient Accumulation steps = {self.config.gradient_accumulation}')
        logger.info(f'  Total optimization steps = {self.config.num_steps}')
        logger.info(f'  Training config = {self.config}')
        self.global_step = 0
        self.first_epoch = 0
        if config.resume_from_checkpoint:
            self._resume_from_checkpoint()

    def compute_text_embeddings(self, prompt):
        logger.info(f'Computing text embeddings for prompt: {prompt}')
        with torch.no_grad():
            (prompt_embeds, pooled_prompt_embeds) = utils.encode_prompt_xl(self.text_encoders, self.tokenizers, prompt)
            prompt_embeds = prompt_embeds.to(self.accelerator.device)
            pooled_prompt_embeds = pooled_prompt_embeds.to(self.accelerator.device)
        return (prompt_embeds, pooled_prompt_embeds)

    def compute_time_ids(self):
        original_size = (self.config.resolution, self.config.resolution)
        target_size = (self.config.resolution, self.config.resolution)
        crops_coords_top_left = (0, 0)
        add_time_ids = list(original_size + crops_coords_top_left + target_size)
        add_time_ids = torch.tensor([add_time_ids])
        add_time_ids = add_time_ids.to(self.accelerator.device, dtype=self.weight_dtype)
        return add_time_ids

    def _setup_xl(self):
        instance_time_ids = self.compute_time_ids()
        if not self.config.train_text_encoder:
            (instance_prompt_hidden_states, instance_pooled_prompt_embeds) = self.compute_text_embeddings(self.config.prompt)
        if self.config.prior_preservation:
            class_time_ids = self.compute_time_ids()
            if not self.config.train_text_encoder:
                (class_prompt_hidden_states, class_pooled_prompt_embeds) = self.compute_text_embeddings(self.config.class_prompt)
        self.add_time_ids = instance_time_ids
        if self.config.prior_preservation:
            self.add_time_ids = torch.cat([self.add_time_ids, class_time_ids], dim=0)
        if not self.config.train_text_encoder:
            self.prompt_embeds = instance_prompt_hidden_states
            self.unet_add_text_embeds = instance_pooled_prompt_embeds
            if self.config.prior_preservation:
                self.prompt_embeds = torch.cat([self.prompt_embeds, class_prompt_hidden_states], dim=0)
                self.unet_add_text_embeds = torch.cat([self.unet_add_text_embeds, class_pooled_prompt_embeds], dim=0)
        else:
            self.tokens_one = utils.tokenize_prompt(self.tokenizers[0], self.config.prompt).input_ids
            self.tokens_two = utils.tokenize_prompt(self.tokenizers[1], self.config.prompt).input_ids
            if self.config.prior_preservation:
                class_tokens_one = utils.tokenize_prompt(self.tokenizers[0], self.config.class_prompt).input_ids
                class_tokens_two = utils.tokenize_prompt(self.tokenizers[1], self.config.class_prompt).input_ids
                self.tokens_one = torch.cat([self.tokens_one, class_tokens_one], dim=0)
                self.tokens_two = torch.cat([self.tokens_two, class_tokens_two], dim=0)

    def _resume_from_checkpoint(self):
        if self.config.resume_from_checkpoint != 'latest':
            path = os.path.basename(self.config.resume_from_checkpoint)
        else:
            dirs = os.listdir(self.config.project_name)
            dirs = [d for d in dirs if d.startswith('checkpoint')]
            dirs = sorted(dirs, key=lambda x: int(x.split('-')[1]))
            path = dirs[-1] if len(dirs) > 0 else None
        if path is None:
            self.accelerator.print(f"Checkpoint '{self.config.resume_from_checkpoint}' does not exist. Starting a new training run.")
            self.config.resume_from_checkpoint = None
        else:
            self.accelerator.print(f'Resuming from checkpoint {path}')
            self.accelerator.load_state(os.path.join(self.config.project_name, path))
            self.global_step = int(path.split('-')[1])
            resume_global_step = self.global_step * self.config.gradient_accumulation
            self.first_epoch = self.global_step // self.num_update_steps_per_epoch
            self.resume_step = resume_global_step % (self.num_update_steps_per_epoch * self.config.gradient_accumulation)

    def _calculate_loss(self, model_pred, noise, model_input, timesteps):
        if model_pred.shape[1] == 6 and (not self.config.xl):
            (model_pred, _) = torch.chunk(model_pred, 2, dim=1)
        if self.noise_scheduler.config.prediction_type == 'epsilon':
            target = noise
        elif self.noise_scheduler.config.prediction_type == 'v_prediction':
            target = self.noise_scheduler.get_velocity(model_input, noise, timesteps)
        else:
            raise ValueError(f'Unknown prediction type {self.noise_scheduler.config.prediction_type}')
        if self.config.prior_preservation:
            (model_pred, model_pred_prior) = torch.chunk(model_pred, 2, dim=0)
            (target, target_prior) = torch.chunk(target, 2, dim=0)
            loss = F.mse_loss(model_pred.float(), target.float(), reduction='mean')
            prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction='mean')
            loss = loss + self.config.prior_loss_weight * prior_loss
        else:
            loss = F.mse_loss(model_pred.float(), target.float(), reduction='mean')
        return loss

    def _clip_gradients(self):
        if self.accelerator.sync_gradients:
            if len(self.text_lora_parameters) == 0:
                params_to_clip = self.unet_lora_parameters
            elif len(self.text_lora_parameters) == 1:
                params_to_clip = itertools.chain(self.unet_lora_parameters, self.text_lora_parameters[0])
            elif len(self.text_lora_parameters) == 2:
                params_to_clip = itertools.chain(self.unet_lora_parameters, self.text_lora_parameters[0], self.text_lora_parameters[1])
            else:
                raise ValueError('More than 2 text encoders are not supported.')
            self.accelerator.clip_grad_norm_(params_to_clip, self.config.max_grad_norm)

    def _save_checkpoint(self):
        if self.accelerator.is_main_process:
            if self.global_step % self.config.checkpointing_steps == 0:
                if self.config.checkpoints_total_limit is not None:
                    checkpoints = os.listdir(self.config.project_name)
                    checkpoints = [d for d in checkpoints if d.startswith('checkpoint')]
                    checkpoints = sorted(checkpoints, key=lambda x: int(x.split('-')[1]))
                    if len(checkpoints) >= self.config.checkpoints_total_limit:
                        num_to_remove = len(checkpoints) - self.config.checkpoints_total_limit + 1
                        removing_checkpoints = checkpoints[0:num_to_remove]
                        logger.info(f'{len(checkpoints)} checkpoints already exist, removing {len(removing_checkpoints)} checkpoints')
                        logger.info(f"removing checkpoints: {', '.join(removing_checkpoints)}")
                        for removing_checkpoint in removing_checkpoints:
                            removing_checkpoint = os.path.join(self.config.project_name, removing_checkpoint)
                            shutil.rmtree(removing_checkpoint)
                save_path = os.path.join(self.config.project_name, f'checkpoint-{self.global_step}')
                self.accelerator.save_state(save_path)
                logger.info(f'Saved state to {save_path}')

    def _get_model_pred(self, batch, channels, noisy_model_input, timesteps, bsz):
        if self.config.xl:
            elems_to_repeat = bsz // 2 if self.config.prior_preservation else bsz
            if not self.config.train_text_encoder:
                unet_added_conditions = {'time_ids': self.add_time_ids.repeat(elems_to_repeat, 1), 'text_embeds': self.unet_add_text_embeds.repeat(elems_to_repeat, 1)}
                model_pred = self.unet(noisy_model_input, timesteps, self.prompt_embeds.repeat(elems_to_repeat, 1, 1), added_cond_kwargs=unet_added_conditions).sample
            else:
                unet_added_conditions = {'time_ids': self.add_time_ids.repeat(elems_to_repeat, 1)}
                (prompt_embeds, pooled_prompt_embeds) = utils.encode_prompt_xl(text_encoders=self.text_encoders, tokenizers=None, prompt=None, text_input_ids_list=[self.tokens_one, self.tokens_two])
                unet_added_conditions.update({'text_embeds': pooled_prompt_embeds.repeat(elems_to_repeat, 1)})
                prompt_embeds = prompt_embeds.repeat(elems_to_repeat, 1, 1)
                model_pred = self.unet(noisy_model_input, timesteps, prompt_embeds, added_cond_kwargs=unet_added_conditions).sample
        else:
            if self.config.pre_compute_text_embeddings:
                encoder_hidden_states = batch['input_ids']
            else:
                encoder_hidden_states = utils.encode_prompt(self.text_encoder1, batch['input_ids'], batch['attention_mask'], text_encoder_use_attention_mask=self.config.text_encoder_use_attention_mask)
            if self.accelerator.unwrap_model(self.unet).config.in_channels == channels * 2:
                noisy_model_input = torch.cat([noisy_model_input, noisy_model_input], dim=1)
            if self.config.class_labels_conditioning == 'timesteps':
                class_labels = timesteps
            else:
                class_labels = None
            model_pred = self.unet(noisy_model_input, timesteps, encoder_hidden_states, class_labels=class_labels).sample
        return model_pred

    def train(self):
        progress_bar = tqdm(range(self.global_step, self.config.num_steps), disable=not self.accelerator.is_local_main_process)
        progress_bar.set_description('Steps')
        for epoch in range(self.first_epoch, self.config.epochs):
            self.unet.train()
            if self.config.train_text_encoder:
                self.text_encoder1.train()
                if self.config.xl:
                    self.text_encoder2.train()
            for (step, batch) in enumerate(self.train_dataloader):
                if self.config.resume_from_checkpoint and epoch == self.first_epoch and (step < self.resume_step):
                    if step % self.config.gradient_accumulation == 0:
                        progress_bar.update(1)
                    continue
                with self.accelerator.accumulate(self.unet):
                    if self.config.xl:
                        pixel_values = batch['pixel_values']
                    else:
                        pixel_values = batch['pixel_values'].to(dtype=self.weight_dtype)
                    if self.vae is not None:
                        model_input = self.vae.encode(pixel_values).latent_dist.sample()
                        model_input = model_input * self.vae.config.scaling_factor
                        model_input = model_input.to(dtype=self.weight_dtype)
                    else:
                        model_input = pixel_values
                    noise = torch.randn_like(model_input)
                    (bsz, channels, height, width) = model_input.shape
                    timesteps = torch.randint(0, self.noise_scheduler.config.num_train_timesteps, (bsz,), device=model_input.device)
                    timesteps = timesteps.long()
                    noisy_model_input = self.noise_scheduler.add_noise(model_input, noise, timesteps)
                    model_pred = self._get_model_pred(batch, channels, noisy_model_input, timesteps, bsz)
                    loss = self._calculate_loss(model_pred, noise, model_input, timesteps)
                    self.accelerator.backward(loss)
                    self._clip_gradients()
                    self.optimizer.step()
                    self.scheduler.step()
                    self.optimizer.zero_grad()
                if self.accelerator.sync_gradients:
                    progress_bar.update(1)
                    self.global_step += 1
                    self._save_checkpoint()
                logs = {'loss': loss.detach().item(), 'lr': self.scheduler.get_last_lr()[0]}
                progress_bar.set_postfix(**logs)
                self.accelerator.log(logs, step=self.global_step)
                if self.global_step >= self.config.num_steps:
                    break
        self.accelerator.wait_for_everyone()
        if self.accelerator.is_main_process:
            self.unet = self.accelerator.unwrap_model(self.unet)
            self.unet = self.unet.to(torch.float32)
            unet_lora_layers = utils.unet_attn_processors_state_dict(self.unet)
            text_encoder_lora_layers_1 = None
            text_encoder_lora_layers_2 = None
            if self.text_encoder1 is not None and self.config.train_text_encoder:
                text_encoder1 = self.accelerator.unwrap_model(self.text_encoder1)
                text_encoder1 = text_encoder1.to(torch.float32)
                text_encoder_lora_layers_1 = text_encoder_lora_state_dict(text_encoder1)
            if self.text_encoder2 is not None and self.config.train_text_encoder:
                text_encoder2 = self.accelerator.unwrap_model(self.text_encoder2)
                text_encoder2 = text_encoder2.to(torch.float32)
                text_encoder_lora_layers_2 = text_encoder_lora_state_dict(text_encoder2)
            if self.config.xl:
                StableDiffusionXLPipeline.save_lora_weights(save_directory=self.config.project_name, unet_lora_layers=unet_lora_layers, text_encoder_lora_layers=text_encoder_lora_layers_1, text_encoder_2_lora_layers=text_encoder_lora_layers_2, safe_serialization=True)
            else:
                LoraLoaderMixin.save_lora_weights(save_directory=self.config.project_name, unet_lora_layers=unet_lora_layers, text_encoder_lora_layers=text_encoder_lora_layers_1, safe_serialization=True)
        self.accelerator.end_training()

    def push_to_hub(self):
        repo_id = create_repo(repo_id=f'{self.config.username}/{self.config.project_name}', exist_ok=True, private=True, token=self.config.token).repo_id
        utils.create_model_card(repo_id, base_model=self.config.model, train_text_encoder=self.config.train_text_encoder, prompt=self.config.prompt, repo_folder=self.config.project_name)
        upload_folder(repo_id=repo_id, folder_path=self.config.project_name, commit_message='End of training', ignore_patterns=['step_*', 'epoch_*'], token=self.config.token)

# File: autotrain-advanced-main/src/autotrain/trainers/dreambooth/utils.py
import os
from huggingface_hub import list_models
from autotrain import logger
VALID_IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.JPG', '.JPEG', '.PNG']
try:
    XL_MODELS = [m.id for m in list(list_models(task='text-to-image', sort='downloads', limit=200, direction=-1, filter=['diffusers:StableDiffusionXLPipeline']))]
except Exception:
    logger.info('Unable to reach Hugging Face Hub, using default models as XL models.')
    XL_MODELS = ['stabilityai/stable-diffusion-xl-base-1.0', 'stabilityai/stable-diffusion-xl-base-0.9', 'diffusers/stable-diffusion-xl-base-1.0', 'stabilityai/sdxl-turbo']

def save_model_card_xl(repo_id: str, base_model=str, train_text_encoder=False, instance_prompt=str, repo_folder=None, vae_path=None):
    img_str = ''
    yaml = f'\n---\ntags:\n- autotrain\n- stable-diffusion-xl\n- stable-diffusion-xl-diffusers\n- text-to-image\n- diffusers\n- lora\n- template:sd-lora\n{img_str}\nbase_model: {base_model}\ninstance_prompt: {instance_prompt}\nlicense: openrail++\n---\n    '
    model_card = f'\n# AutoTrain SDXL LoRA DreamBooth - {repo_id}\n\n<Gallery />\n\n## Model description\n\nThese are {repo_id} LoRA adaption weights for {base_model}.\n\nThe weights were trained  using [DreamBooth](https://dreambooth.github.io/).\n\nLoRA for the text encoder was enabled: {train_text_encoder}.\n\nSpecial VAE used for training: {vae_path}.\n\n## Trigger words\n\nYou should use {instance_prompt} to trigger the image generation.\n\n## Download model\n\nWeights for this model are available in Safetensors format.\n\n[Download]({repo_id}/tree/main) them in the Files & versions tab.\n\n'
    with open(os.path.join(repo_folder, 'README.md'), 'w') as f:
        f.write(yaml + model_card)

def save_model_card(repo_id: str, base_model=str, train_text_encoder=False, instance_prompt=str, repo_folder=None):
    img_str = ''
    model_description = f'\n# AutoTrain LoRA DreamBooth - {repo_id}\n\nThese are LoRA adaption weights for {base_model}. The weights were trained on {instance_prompt} using [DreamBooth](https://dreambooth.github.io/).\nLoRA for the text encoder was enabled: {train_text_encoder}.\n'
    yaml = f'\n---\ntags:\n- autotrain\n- stable-diffusion\n- stable-diffusion-diffusers\n- text-to-image\n- diffusers\n- lora\n- template:sd-lora\n{img_str}\nbase_model: {base_model}\ninstance_prompt: {instance_prompt}\nlicense: openrail++\n---\n    '
    with open(os.path.join(repo_folder, 'README.md'), 'w') as f:
        f.write(yaml + model_description)

# File: autotrain-advanced-main/src/autotrain/trainers/extractive_question_answering/__main__.py
import argparse
import copy
import json
from functools import partial
from accelerate.state import PartialState
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from transformers import AutoConfig, AutoModelForQuestionAnswering, AutoTokenizer, EarlyStoppingCallback, Trainer, TrainingArguments
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, monitor, pause_space, remove_autotrain_data, save_training_params
from autotrain.trainers.extractive_question_answering import utils
from autotrain.trainers.extractive_question_answering.dataset import ExtractiveQuestionAnsweringDataset
from autotrain.trainers.extractive_question_answering.params import ExtractiveQuestionAnsweringParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = ExtractiveQuestionAnsweringParams(**config)
    train_data = None
    valid_data = None
    if config.train_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            train_data = load_from_disk(config.data_path)[config.train_split]
        elif ':' in config.train_split:
            (dataset_config_name, split) = config.train_split.split(':')
            train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
    logger.info(train_data)
    if config.valid_split is not None:
        logger.info(valid_data)
    model_config = AutoConfig.from_pretrained(config.model, allow_remote_code=ALLOW_REMOTE_CODE, token=config.token)
    try:
        model = AutoModelForQuestionAnswering.from_pretrained(config.model, config=model_config, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    except OSError:
        model = AutoModelForQuestionAnswering.from_pretrained(config.model, config=model_config, from_tf=True, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    tokenizer = AutoTokenizer.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    use_v2 = False
    if config.valid_split is not None:
        id_column = list(range(len(valid_data)))
        for data in valid_data:
            if -1 in data[config.answer_column]['answer_start']:
                use_v2 = True
                break
        valid_data = valid_data.add_column('id', id_column)
        column_names = valid_data.column_names
        partial_process = partial(utils.prepare_qa_validation_features, tokenizer=tokenizer, config=config)
        processed_eval_dataset = valid_data.map(partial_process, batched=True, remove_columns=column_names, num_proc=2, desc='Running tokenizer on validation dataset')
        orig_valid_data = copy.deepcopy(valid_data)
    train_data = ExtractiveQuestionAnsweringDataset(data=train_data, tokenizer=tokenizer, config=config)
    if config.valid_split is not None:
        valid_data = ExtractiveQuestionAnsweringDataset(data=valid_data, tokenizer=tokenizer, config=config)
    if config.logging_steps == -1:
        if config.valid_split is not None:
            logging_steps = int(0.2 * len(valid_data) / config.batch_size)
        else:
            logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=2 * config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False)
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    if config.valid_split is not None:
        early_stop = EarlyStoppingCallback(early_stopping_patience=config.early_stopping_patience, early_stopping_threshold=config.early_stopping_threshold)
        callbacks_to_use = [early_stop]
    else:
        callbacks_to_use = []
    callbacks_to_use.extend([UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()])
    if config.valid_split is not None:
        logger.info(processed_eval_dataset)
        compute_metrics = partial(utils.compute_metrics, eval_dataset=processed_eval_dataset, eval_examples=orig_valid_data, config=config, use_v2=use_v2)
    else:
        compute_metrics = None
    args = TrainingArguments(**training_args)
    trainer_args = dict(args=args, model=model, callbacks=callbacks_to_use, compute_metrics=compute_metrics)
    trainer = Trainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    logger.info('Finished training, saving model...')
    trainer.save_model(config.project_name)
    tokenizer.save_pretrained(config.project_name)
    model_card = utils.create_model_card(config, trainer)
    with open(f'{config.project_name}/README.md', 'w') as f:
        f.write(model_card)
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            save_training_params(config)
            logger.info('Pushing model to hub...')
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)
if __name__ == '__main__':
    args = parse_args()
    training_config = json.load(open(args.training_config))
    config = ExtractiveQuestionAnsweringParams(**training_config)
    train(config)

# File: autotrain-advanced-main/src/autotrain/trainers/extractive_question_answering/dataset.py
from functools import partial
from autotrain import logger

def _prepare_dataset(examples, tokenizer, config):
    pad_on_right = tokenizer.padding_side == 'right'
    tokenized_examples = tokenizer(examples[config.question_column if pad_on_right else config.text_column], examples[config.text_column if pad_on_right else config.question_column], truncation='only_second' if pad_on_right else 'only_first', max_length=config.max_seq_length, stride=config.max_doc_stride, return_overflowing_tokens=True, return_offsets_mapping=True, padding='max_length')
    sample_mapping = tokenized_examples.pop('overflow_to_sample_mapping')
    offset_mapping = tokenized_examples.pop('offset_mapping')
    tokenized_examples['start_positions'] = []
    tokenized_examples['end_positions'] = []
    for (i, offsets) in enumerate(offset_mapping):
        input_ids = tokenized_examples['input_ids'][i]
        if tokenizer.cls_token_id in input_ids:
            cls_index = input_ids.index(tokenizer.cls_token_id)
        elif tokenizer.bos_token_id in input_ids:
            cls_index = input_ids.index(tokenizer.bos_token_id)
        else:
            cls_index = 0
        sequence_ids = tokenized_examples.sequence_ids(i)
        sample_index = sample_mapping[i]
        answers = examples[config.answer_column][sample_index]
        if len(answers['answer_start']) == 0:
            tokenized_examples['start_positions'].append(cls_index)
            tokenized_examples['end_positions'].append(cls_index)
        else:
            start_char = answers['answer_start'][0]
            end_char = start_char + len(answers['text'][0])
            token_start_index = 0
            while sequence_ids[token_start_index] != (1 if pad_on_right else 0):
                token_start_index += 1
            token_end_index = len(input_ids) - 1
            while sequence_ids[token_end_index] != (1 if pad_on_right else 0):
                token_end_index -= 1
            if not (offsets[token_start_index][0] <= start_char and offsets[token_end_index][1] >= end_char):
                tokenized_examples['start_positions'].append(cls_index)
                tokenized_examples['end_positions'].append(cls_index)
            else:
                while token_start_index < len(offsets) and offsets[token_start_index][0] <= start_char:
                    token_start_index += 1
                tokenized_examples['start_positions'].append(token_start_index - 1)
                while offsets[token_end_index][1] >= end_char:
                    token_end_index -= 1
                tokenized_examples['end_positions'].append(token_end_index + 1)
    return tokenized_examples

class ExtractiveQuestionAnsweringDataset:

    def __init__(self, data, tokenizer, config):
        self.data = data
        self.tokenizer = tokenizer
        self.config = config
        logger.info('Processing data for Extractive QA')
        mapping_function = partial(_prepare_dataset, tokenizer=self.tokenizer, config=self.config)
        self.tokenized_data = self.data.map(mapping_function, batched=True, remove_columns=self.data.column_names)

    def __len__(self):
        return len(self.tokenized_data)

    def __getitem__(self, item):
        return self.tokenized_data[item]

# File: autotrain-advanced-main/src/autotrain/trainers/extractive_question_answering/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class ExtractiveQuestionAnsweringParams(AutoTrainParams):
    data_path: str = Field(None, title='Data path')
    model: str = Field('bert-base-uncased', title='Model name')
    lr: float = Field(5e-05, title='Learning rate')
    epochs: int = Field(3, title='Number of training epochs')
    max_seq_length: int = Field(128, title='Max sequence length')
    max_doc_stride: int = Field(128, title='Max doc stride')
    batch_size: int = Field(8, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(1, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    seed: int = Field(42, title='Seed')
    train_split: str = Field('train', title='Train split')
    valid_split: Optional[str] = Field(None, title='Validation split')
    text_column: str = Field('context', title='context/text column')
    question_column: str = Field('question', title='question column')
    answer_column: str = Field('answers', title='answer column')
    logging_steps: int = Field(-1, title='Logging steps')
    project_name: str = Field('project-name', title='Output directory')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    save_total_limit: int = Field(1, title='Save total limit')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    log: str = Field('none', title='Logging using experiment tracking')
    early_stopping_patience: int = Field(5, title='Early stopping patience')
    early_stopping_threshold: float = Field(0.01, title='Early stopping threshold')

# File: autotrain-advanced-main/src/autotrain/trainers/extractive_question_answering/utils.py
import collections
import json
import os
import numpy as np
from datasets import load_metric
from transformers import EvalPrediction
from autotrain import logger
MODEL_CARD = '\n---\nlibrary_name: transformers\ntags:\n- autotrain\n- question-answering{base_model}\nwidget:\n- text: "Who loves AutoTrain?"\n  context: "Everyone loves AutoTrain"{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\n- Problem type: Extractive Question Answering\n\n## Validation Metrics\n\n{validation_metrics}\n\n## Usage\n\n\n```python\nimport torch\n\nfrom transformers import AutoModelForQuestionAnswering, AutoTokenizer\n\nmodel = AutoModelForQuestionAnswering.from_pretrained(...)\n\ntokenizer = AutoTokenizer.from_pretrained(...)\n\nfrom transformers import BertTokenizer, BertForQuestionAnswering\n\nquestion, text = "Who loves AutoTrain?", "Everyone loves AutoTrain"\n\ninputs = tokenizer(question, text, return_tensors=\'pt\')\n\nstart_positions = torch.tensor([1])\n\nend_positions = torch.tensor([3])\n\noutputs = model(**inputs, start_positions=start_positions, end_positions=end_positions)\n\nloss = outputs.loss\n\nstart_scores = outputs.start_logits\n\nend_scores = outputs.end_logits\n```\n'
SQUAD_METRIC = load_metric('squad')
SQUAD_V2_METRIC = load_metric('squad_v2')

def postprocess_qa_predictions(examples, features, predictions, config, version_2_with_negative=False, n_best_size=20, max_answer_length=30, null_score_diff_threshold=0.0, output_dir=None, prefix=None):
    if len(predictions) != 2:
        raise ValueError('`predictions` should be a tuple with two elements (start_logits, end_logits).')
    (all_start_logits, all_end_logits) = predictions
    if len(predictions[0]) != len(features):
        raise ValueError(f'Got {len(predictions[0])} predictions and {len(features)} features.')
    example_id_to_index = {k: i for (i, k) in enumerate(examples['id'])}
    features_per_example = collections.defaultdict(list)
    for (i, feature) in enumerate(features):
        features_per_example[example_id_to_index[feature['example_id']]].append(i)
    all_predictions = collections.OrderedDict()
    all_nbest_json = collections.OrderedDict()
    if version_2_with_negative:
        scores_diff_json = collections.OrderedDict()
    logger.info(f'Post-processing {len(examples)} example predictions split into {len(features)} features.')
    for (example_index, example) in enumerate(examples):
        feature_indices = features_per_example[example_index]
        min_null_prediction = None
        prelim_predictions = []
        for feature_index in feature_indices:
            start_logits = all_start_logits[feature_index]
            end_logits = all_end_logits[feature_index]
            offset_mapping = features[feature_index]['offset_mapping']
            token_is_max_context = features[feature_index].get('token_is_max_context', None)
            feature_null_score = start_logits[0] + end_logits[0]
            if min_null_prediction is None or min_null_prediction['score'] > feature_null_score:
                min_null_prediction = {'offsets': (0, 0), 'score': feature_null_score, 'start_logit': start_logits[0], 'end_logit': end_logits[0]}
            start_indexes = np.argsort(start_logits)[-1:-n_best_size - 1:-1].tolist()
            end_indexes = np.argsort(end_logits)[-1:-n_best_size - 1:-1].tolist()
            for start_index in start_indexes:
                for end_index in end_indexes:
                    if start_index >= len(offset_mapping) or end_index >= len(offset_mapping) or offset_mapping[start_index] is None or (len(offset_mapping[start_index]) < 2) or (offset_mapping[end_index] is None) or (len(offset_mapping[end_index]) < 2):
                        continue
                    if end_index < start_index or end_index - start_index + 1 > max_answer_length:
                        continue
                    if token_is_max_context is not None and (not token_is_max_context.get(str(start_index), False)):
                        continue
                    prelim_predictions.append({'offsets': (offset_mapping[start_index][0], offset_mapping[end_index][1]), 'score': start_logits[start_index] + end_logits[end_index], 'start_logit': start_logits[start_index], 'end_logit': end_logits[end_index]})
        if version_2_with_negative and min_null_prediction is not None:
            prelim_predictions.append(min_null_prediction)
            null_score = min_null_prediction['score']
        predictions = sorted(prelim_predictions, key=lambda x: x['score'], reverse=True)[:n_best_size]
        if version_2_with_negative and min_null_prediction is not None and (not any((p['offsets'] == (0, 0) for p in predictions))):
            predictions.append(min_null_prediction)
        context = example[config.text_column]
        for pred in predictions:
            offsets = pred.pop('offsets')
            pred['text'] = context[offsets[0]:offsets[1]]
        if len(predictions) == 0 or (len(predictions) == 1 and predictions[0]['text'] == ''):
            predictions.insert(0, {'text': 'empty', 'start_logit': 0.0, 'end_logit': 0.0, 'score': 0.0})
        scores = np.array([pred.pop('score') for pred in predictions])
        exp_scores = np.exp(scores - np.max(scores))
        probs = exp_scores / exp_scores.sum()
        for (prob, pred) in zip(probs, predictions):
            pred['probability'] = prob
        if not version_2_with_negative:
            all_predictions[example['id']] = predictions[0]['text']
        else:
            i = 0
            while predictions[i]['text'] == '':
                i += 1
            best_non_null_pred = predictions[i]
            score_diff = null_score - best_non_null_pred['start_logit'] - best_non_null_pred['end_logit']
            scores_diff_json[example['id']] = float(score_diff)
            if score_diff > null_score_diff_threshold:
                all_predictions[example['id']] = ''
            else:
                all_predictions[example['id']] = best_non_null_pred['text']
        all_nbest_json[example['id']] = [{k: float(v) if isinstance(v, (np.float16, np.float32, np.float64)) else v for (k, v) in pred.items()} for pred in predictions]
    if output_dir is not None:
        if not os.path.isdir(output_dir):
            raise EnvironmentError(f'{output_dir} is not a directory.')
        prediction_file = os.path.join(output_dir, 'predictions.json' if prefix is None else f'{prefix}_predictions.json')
        nbest_file = os.path.join(output_dir, 'nbest_predictions.json' if prefix is None else f'{prefix}_nbest_predictions.json')
        if version_2_with_negative:
            null_odds_file = os.path.join(output_dir, 'null_odds.json' if prefix is None else f'{prefix}_null_odds.json')
        logger.info(f'Saving predictions to {prediction_file}.')
        with open(prediction_file, 'w') as writer:
            writer.write(json.dumps(all_predictions, indent=4) + '\n')
        logger.info(f'Saving nbest_preds to {nbest_file}.')
        with open(nbest_file, 'w') as writer:
            writer.write(json.dumps(all_nbest_json, indent=4) + '\n')
        if version_2_with_negative:
            logger.info(f'Saving null_odds to {null_odds_file}.')
            with open(null_odds_file, 'w') as writer:
                writer.write(json.dumps(scores_diff_json, indent=4) + '\n')
    return all_predictions

def post_processing_function_qa(examples, features, predictions, version_2_with_negative, config, stage='eval'):
    predictions = postprocess_qa_predictions(examples=examples, features=features, predictions=predictions, version_2_with_negative=version_2_with_negative, n_best_size=20, max_answer_length=30, null_score_diff_threshold=0.0, output_dir=None, prefix=stage, config=config)
    if version_2_with_negative:
        formatted_predictions = [{'id': k, 'prediction_text': v, 'no_answer_probability': 0.0} for (k, v) in predictions.items()]
    else:
        formatted_predictions = [{'id': k, 'prediction_text': v} for (k, v) in predictions.items()]
    references = [{'id': str(ex['id']), 'answers': ex[config.answer_column]} for ex in examples]
    return EvalPrediction(predictions=formatted_predictions, label_ids=references)

def compute_metrics(pred, eval_dataset, eval_examples, use_v2, config):
    (preds, label_ids) = post_processing_function_qa(eval_examples, eval_dataset, pred.predictions, use_v2, config)
    if use_v2:
        result = SQUAD_V2_METRIC.compute(predictions=preds, references=label_ids)
    else:
        result = SQUAD_METRIC.compute(predictions=preds, references=label_ids)
    return {k: round(v, 4) for (k, v) in result.items()}

def create_model_card(config, trainer):
    if config.valid_split is not None:
        eval_scores = trainer.evaluate()
        eval_scores = [f"{k[len('eval_'):]}: {v}" for (k, v) in eval_scores.items()]
        eval_scores = '\n\n'.join(eval_scores)
    else:
        eval_scores = 'No validation metrics available'
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, validation_metrics=eval_scores, base_model=base_model)
    return model_card

def prepare_qa_validation_features(examples, tokenizer, config):
    pad_on_right = tokenizer.padding_side == 'right'
    examples[config.question_column] = [q.lstrip() for q in examples[config.question_column]]
    tokenized_examples = tokenizer(examples[config.question_column if pad_on_right else config.text_column], examples[config.text_column if pad_on_right else config.question_column], truncation='only_second' if pad_on_right else 'only_first', max_length=config.max_seq_length, stride=config.max_doc_stride, return_overflowing_tokens=True, return_offsets_mapping=True, padding='max_length')
    sample_mapping = tokenized_examples.pop('overflow_to_sample_mapping')
    tokenized_examples['example_id'] = []
    for i in range(len(tokenized_examples['input_ids'])):
        sequence_ids = tokenized_examples.sequence_ids(i)
        context_index = 1 if pad_on_right else 0
        sample_index = sample_mapping[i]
        tokenized_examples['example_id'].append(examples['id'][sample_index])
        tokenized_examples['offset_mapping'][i] = [o if sequence_ids[k] == context_index else None for (k, o) in enumerate(tokenized_examples['offset_mapping'][i])]
    return tokenized_examples

# File: autotrain-advanced-main/src/autotrain/trainers/generic/__main__.py
import argparse
import json
from autotrain import logger
from autotrain.trainers.common import monitor, pause_space
from autotrain.trainers.generic import utils
from autotrain.trainers.generic.params import GenericParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--config', type=str, required=True)
    return parser.parse_args()

@monitor
def run(config):
    if isinstance(config, dict):
        config = GenericParams(**config)
    logger.info('Downloading data repo...')
    utils.pull_dataset_repo(config)
    logger.info('Unintalling requirements...')
    utils.uninstall_requirements(config)
    logger.info('Installing requirements...')
    utils.install_requirements(config)
    logger.info('Running command...')
    utils.run_command(config)
    pause_space(config)
if __name__ == '__main__':
    args = parse_args()
    _config = json.load(open(args.config))
    _config = GenericParams(**_config)
    run(_config)

# File: autotrain-advanced-main/src/autotrain/trainers/generic/params.py
from typing import Dict, Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class GenericParams(AutoTrainParams):
    username: str = Field(None, title='Hugging Face Username')
    project_name: str = Field('project-name', title='path to script.py')
    data_path: str = Field(None, title='Data path')
    token: str = Field(None, title='Hub Token')
    script_path: str = Field(None, title='Script path')
    env: Optional[Dict[str, str]] = Field(None, title='Environment Variables')
    args: Optional[Dict[str, str]] = Field(None, title='Arguments')

# File: autotrain-advanced-main/src/autotrain/trainers/generic/utils.py
import os
import subprocess
import requests
from huggingface_hub import HfApi, snapshot_download
from autotrain import logger

def create_dataset_repo(username, project_name, script_path, token):
    logger.info('Creating dataset repo...')
    api = HfApi(token=token)
    repo_id = f'{username}/autotrain-{project_name}'
    api.create_repo(repo_id=repo_id, repo_type='dataset', private=True)
    logger.info('Uploading dataset...')
    api.upload_folder(folder_path=script_path, repo_id=repo_id, repo_type='dataset')
    logger.info('Dataset uploaded.')
    return repo_id

def pull_dataset_repo(params):
    snapshot_download(repo_id=params.data_path, local_dir=params.project_name, token=params.token, repo_type='dataset')

def uninstall_requirements(params):
    if os.path.exists(f'{params.project_name}/requirements.txt'):
        uninstall_list = []
        with open(f'{params.project_name}/requirements.txt', 'r', encoding='utf-8') as f:
            for line in f:
                if line.startswith('-'):
                    uninstall_list.append(line[1:])
        with open(f'{params.project_name}/uninstall.txt', 'w', encoding='utf-8') as f:
            for line in uninstall_list:
                f.write(line)
        pipe = subprocess.Popen(['pip', 'uninstall', '-r', 'uninstall.txt', '-y'], cwd=params.project_name)
        pipe.wait()
        logger.info('Requirements uninstalled.')
        return

def install_requirements(params):
    if os.path.exists(f'{params.project_name}/requirements.txt'):
        install_list = []
        with open(f'{params.project_name}/requirements.txt', 'r', encoding='utf-8') as f:
            for line in f:
                if not line.startswith('-'):
                    install_list.append(line)
        with open(f'{params.project_name}/requirements.txt', 'w', encoding='utf-8') as f:
            for line in install_list:
                f.write(line)
        pipe = subprocess.Popen(['pip', 'install', '-r', 'requirements.txt'], cwd=params.project_name)
        pipe.wait()
        logger.info('Requirements installed.')
        return
    logger.info('No requirements.txt found. Skipping requirements installation.')
    return

def run_command(params):
    if os.path.exists(f'{params.project_name}/script.py'):
        cmd = ['python', 'script.py']
        if params.args:
            for arg in params.args:
                cmd.append(f'--{arg}')
                if params.args[arg] != '':
                    cmd.append(params.args[arg])
        pipe = subprocess.Popen(cmd, cwd=params.project_name)
        pipe.wait()
        logger.info('Command finished.')
        return
    raise ValueError('No script.py found.')

def pause_endpoint(params):
    endpoint_id = os.environ['ENDPOINT_ID']
    username = endpoint_id.split('/')[0]
    project_name = endpoint_id.split('/')[1]
    api_url = f'https://api.endpoints.huggingface.cloud/v2/endpoint/{username}/{project_name}/pause'
    headers = {'Authorization': f'Bearer {params.token}'}
    r = requests.post(api_url, headers=headers, timeout=120)
    return r.json()

# File: autotrain-advanced-main/src/autotrain/trainers/image_classification/__main__.py
import argparse
import json
from accelerate.state import PartialState
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from transformers import AutoConfig, AutoImageProcessor, AutoModelForImageClassification, EarlyStoppingCallback, Trainer, TrainingArguments
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, monitor, pause_space, remove_autotrain_data, save_training_params
from autotrain.trainers.image_classification import utils
from autotrain.trainers.image_classification.params import ImageClassificationParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = ImageClassificationParams(**config)
    valid_data = None
    if config.data_path == f'{config.project_name}/autotrain-data':
        train_data = load_from_disk(config.data_path)[config.train_split]
    elif ':' in config.train_split:
        (dataset_config_name, split) = config.train_split.split(':')
        train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
    else:
        train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
    logger.info(f'Train data: {train_data}')
    logger.info(f'Valid data: {valid_data}')
    classes = train_data.features[config.target_column].names
    logger.info(f'Classes: {classes}')
    label2id = {c: i for (i, c) in enumerate(classes)}
    num_classes = len(classes)
    if num_classes < 2:
        raise ValueError('Invalid number of classes. Must be greater than 1.')
    if config.valid_split is not None:
        num_classes_valid = len(valid_data.unique(config.target_column))
        if num_classes_valid != num_classes:
            raise ValueError(f'Number of classes in train and valid are not the same. Training has {num_classes} and valid has {num_classes_valid}')
    model_config = AutoConfig.from_pretrained(config.model, num_labels=num_classes, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token)
    model_config._num_labels = len(label2id)
    model_config.label2id = label2id
    model_config.id2label = {v: k for (k, v) in label2id.items()}
    try:
        model = AutoModelForImageClassification.from_pretrained(config.model, config=model_config, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    except OSError:
        model = AutoModelForImageClassification.from_pretrained(config.model, config=model_config, from_tf=True, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    image_processor = AutoImageProcessor.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    (train_data, valid_data) = utils.process_data(train_data, valid_data, image_processor, config)
    if config.logging_steps == -1:
        if config.valid_split is not None:
            logging_steps = int(0.2 * len(valid_data) / config.batch_size)
        else:
            logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=2 * config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False)
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    if config.valid_split is not None:
        early_stop = EarlyStoppingCallback(early_stopping_patience=config.early_stopping_patience, early_stopping_threshold=config.early_stopping_threshold)
        callbacks_to_use = [early_stop]
    else:
        callbacks_to_use = []
    callbacks_to_use.extend([UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()])
    args = TrainingArguments(**training_args)
    trainer_args = dict(args=args, model=model, callbacks=callbacks_to_use, compute_metrics=utils._binary_classification_metrics if num_classes == 2 else utils._multi_class_classification_metrics)
    trainer = Trainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    logger.info('Finished training, saving model...')
    trainer.save_model(config.project_name)
    image_processor.save_pretrained(config.project_name)
    model_card = utils.create_model_card(config, trainer, num_classes)
    with open(f'{config.project_name}/README.md', 'w') as f:
        f.write(model_card)
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            save_training_params(config)
            logger.info('Pushing model to hub...')
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)
if __name__ == '__main__':
    _args = parse_args()
    training_config = json.load(open(_args.training_config))
    _config = ImageClassificationParams(**training_config)
    train(_config)

# File: autotrain-advanced-main/src/autotrain/trainers/image_classification/dataset.py
import numpy as np
import torch

class ImageClassificationDataset:

    def __init__(self, data, transforms, config):
        self.data = data
        self.transforms = transforms
        self.config = config

    def __len__(self):
        return len(self.data)

    def __getitem__(self, item):
        image = self.data[item][self.config.image_column]
        target = int(self.data[item][self.config.target_column])
        image = self.transforms(image=np.array(image.convert('RGB')))['image']
        image = np.transpose(image, (2, 0, 1)).astype(np.float32)
        return {'pixel_values': torch.tensor(image, dtype=torch.float), 'labels': torch.tensor(target, dtype=torch.long)}

# File: autotrain-advanced-main/src/autotrain/trainers/image_classification/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class ImageClassificationParams(AutoTrainParams):
    data_path: str = Field(None, title='Data path')
    model: str = Field('google/vit-base-patch16-224', title='Model name')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    lr: float = Field(5e-05, title='Learning rate')
    epochs: int = Field(3, title='Number of training epochs')
    batch_size: int = Field(8, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(1, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    seed: int = Field(42, title='Seed')
    train_split: str = Field('train', title='Train split')
    valid_split: Optional[str] = Field(None, title='Validation split')
    logging_steps: int = Field(-1, title='Logging steps')
    project_name: str = Field('project-name', title='Output directory')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    save_total_limit: int = Field(1, title='Save total limit')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    image_column: str = Field('image', title='Image column')
    target_column: str = Field('target', title='Target column')
    log: str = Field('none', title='Logging using experiment tracking')
    early_stopping_patience: int = Field(5, title='Early stopping patience')
    early_stopping_threshold: float = Field(0.01, title='Early stopping threshold')

# File: autotrain-advanced-main/src/autotrain/trainers/image_classification/utils.py
import os
import albumentations as A
import numpy as np
from sklearn import metrics
from autotrain.trainers.image_classification.dataset import ImageClassificationDataset
BINARY_CLASSIFICATION_EVAL_METRICS = ('eval_loss', 'eval_accuracy', 'eval_f1', 'eval_auc', 'eval_precision', 'eval_recall')
MULTI_CLASS_CLASSIFICATION_EVAL_METRICS = ('eval_loss', 'eval_accuracy', 'eval_f1_macro', 'eval_f1_micro', 'eval_f1_weighted', 'eval_precision_macro', 'eval_precision_micro', 'eval_precision_weighted', 'eval_recall_macro', 'eval_recall_micro', 'eval_recall_weighted')
MODEL_CARD = '\n---\ntags:\n- autotrain\n- image-classification{base_model}\nwidget:\n- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg\n  example_title: Tiger\n- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/teapot.jpg\n  example_title: Teapot\n- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/palace.jpg\n  example_title: Palace{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\n- Problem type: Image Classification\n\n## Validation Metrics\n{validation_metrics}\n'

def _binary_classification_metrics(pred):
    (raw_predictions, labels) = pred
    predictions = np.argmax(raw_predictions, axis=1)
    result = {'f1': metrics.f1_score(labels, predictions), 'precision': metrics.precision_score(labels, predictions), 'recall': metrics.recall_score(labels, predictions), 'auc': metrics.roc_auc_score(labels, raw_predictions[:, 1]), 'accuracy': metrics.accuracy_score(labels, predictions)}
    return result

def _multi_class_classification_metrics(pred):
    (raw_predictions, labels) = pred
    predictions = np.argmax(raw_predictions, axis=1)
    results = {'f1_macro': metrics.f1_score(labels, predictions, average='macro'), 'f1_micro': metrics.f1_score(labels, predictions, average='micro'), 'f1_weighted': metrics.f1_score(labels, predictions, average='weighted'), 'precision_macro': metrics.precision_score(labels, predictions, average='macro'), 'precision_micro': metrics.precision_score(labels, predictions, average='micro'), 'precision_weighted': metrics.precision_score(labels, predictions, average='weighted'), 'recall_macro': metrics.recall_score(labels, predictions, average='macro'), 'recall_micro': metrics.recall_score(labels, predictions, average='micro'), 'recall_weighted': metrics.recall_score(labels, predictions, average='weighted'), 'accuracy': metrics.accuracy_score(labels, predictions)}
    return results

def process_data(train_data, valid_data, image_processor, config):
    if 'shortest_edge' in image_processor.size:
        size = image_processor.size['shortest_edge']
    else:
        size = (image_processor.size['height'], image_processor.size['width'])
    try:
        (height, width) = size
    except TypeError:
        height = size
        width = size
    train_transforms = A.Compose([A.RandomResizedCrop(height=height, width=width), A.RandomRotate90(), A.HorizontalFlip(p=0.5), A.RandomBrightnessContrast(p=0.2), A.Normalize(mean=image_processor.image_mean, std=image_processor.image_std)])
    val_transforms = A.Compose([A.Resize(height=height, width=width), A.Normalize(mean=image_processor.image_mean, std=image_processor.image_std)])
    train_data = ImageClassificationDataset(train_data, train_transforms, config)
    if valid_data is not None:
        valid_data = ImageClassificationDataset(valid_data, val_transforms, config)
        return (train_data, valid_data)
    return (train_data, None)

def create_model_card(config, trainer, num_classes):
    if config.valid_split is not None:
        eval_scores = trainer.evaluate()
        valid_metrics = BINARY_CLASSIFICATION_EVAL_METRICS if num_classes == 2 else MULTI_CLASS_CLASSIFICATION_EVAL_METRICS
        eval_scores = [f"{k[len('eval_'):]}: {v}" for (k, v) in eval_scores.items() if k in valid_metrics]
        eval_scores = '\n\n'.join(eval_scores)
    else:
        eval_scores = 'No validation metrics available'
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, validation_metrics=eval_scores, base_model=base_model)
    return model_card

# File: autotrain-advanced-main/src/autotrain/trainers/image_regression/__main__.py
import argparse
import json
from accelerate.state import PartialState
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from transformers import AutoConfig, AutoImageProcessor, AutoModelForImageClassification, EarlyStoppingCallback, Trainer, TrainingArguments
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, monitor, pause_space, remove_autotrain_data, save_training_params
from autotrain.trainers.image_regression import utils
from autotrain.trainers.image_regression.params import ImageRegressionParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = ImageRegressionParams(**config)
    valid_data = None
    if config.data_path == f'{config.project_name}/autotrain-data':
        train_data = load_from_disk(config.data_path)[config.train_split]
    elif ':' in config.train_split:
        (dataset_config_name, split) = config.train_split.split(':')
        train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
    else:
        train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
    logger.info(f'Train data: {train_data}')
    logger.info(f'Valid data: {valid_data}')
    model_config = AutoConfig.from_pretrained(config.model, num_labels=1, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token)
    model_config._num_labels = 1
    label2id = {'target': 0}
    model_config.label2id = label2id
    model_config.id2label = {v: k for (k, v) in label2id.items()}
    try:
        model = AutoModelForImageClassification.from_pretrained(config.model, config=model_config, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    except OSError:
        model = AutoModelForImageClassification.from_pretrained(config.model, config=model_config, from_tf=True, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    image_processor = AutoImageProcessor.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    (train_data, valid_data) = utils.process_data(train_data, valid_data, image_processor, config)
    if config.logging_steps == -1:
        if config.valid_split is not None:
            logging_steps = int(0.2 * len(valid_data) / config.batch_size)
        else:
            logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=2 * config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False)
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    if config.valid_split is not None:
        early_stop = EarlyStoppingCallback(early_stopping_patience=config.early_stopping_patience, early_stopping_threshold=config.early_stopping_threshold)
        callbacks_to_use = [early_stop]
    else:
        callbacks_to_use = []
    callbacks_to_use.extend([UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()])
    args = TrainingArguments(**training_args)
    trainer_args = dict(args=args, model=model, callbacks=callbacks_to_use, compute_metrics=utils.image_regression_metrics)
    trainer = Trainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    logger.info('Finished training, saving model...')
    trainer.save_model(config.project_name)
    image_processor.save_pretrained(config.project_name)
    model_card = utils.create_model_card(config, trainer)
    with open(f'{config.project_name}/README.md', 'w') as f:
        f.write(model_card)
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            save_training_params(config)
            logger.info('Pushing model to hub...')
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)
if __name__ == '__main__':
    _args = parse_args()
    training_config = json.load(open(_args.training_config))
    _config = ImageRegressionParams(**training_config)
    train(_config)

# File: autotrain-advanced-main/src/autotrain/trainers/image_regression/dataset.py
import numpy as np
import torch

class ImageRegressionDataset:

    def __init__(self, data, transforms, config):
        self.data = data
        self.transforms = transforms
        self.config = config

    def __len__(self):
        return len(self.data)

    def __getitem__(self, item):
        image = self.data[item][self.config.image_column]
        target = self.data[item][self.config.target_column]
        image = self.transforms(image=np.array(image.convert('RGB')))['image']
        image = np.transpose(image, (2, 0, 1)).astype(np.float32)
        return {'pixel_values': torch.tensor(image, dtype=torch.float), 'labels': torch.tensor(target, dtype=torch.float)}

# File: autotrain-advanced-main/src/autotrain/trainers/image_regression/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class ImageRegressionParams(AutoTrainParams):
    data_path: str = Field(None, title='Data path')
    model: str = Field('google/vit-base-patch16-224', title='Model name')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    lr: float = Field(5e-05, title='Learning rate')
    epochs: int = Field(3, title='Number of training epochs')
    batch_size: int = Field(8, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(1, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    seed: int = Field(42, title='Seed')
    train_split: str = Field('train', title='Train split')
    valid_split: Optional[str] = Field(None, title='Validation split')
    logging_steps: int = Field(-1, title='Logging steps')
    project_name: str = Field('project-name', title='Output directory')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    save_total_limit: int = Field(1, title='Save total limit')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    image_column: str = Field('image', title='Image column')
    target_column: str = Field('target', title='Target column')
    log: str = Field('none', title='Logging using experiment tracking')
    early_stopping_patience: int = Field(5, title='Early stopping patience')
    early_stopping_threshold: float = Field(0.01, title='Early stopping threshold')

# File: autotrain-advanced-main/src/autotrain/trainers/image_regression/utils.py
import os
import albumentations as A
import numpy as np
from sklearn import metrics
from autotrain.trainers.image_regression.dataset import ImageRegressionDataset
VALID_METRICS = ['eval_loss', 'eval_mse', 'eval_mae', 'eval_r2', 'eval_rmse', 'eval_explained_variance']
MODEL_CARD = '\n---\ntags:\n- autotrain\n- vision\n- image-classification\n- image-regression{base_model}\nwidget:\n- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg\n  example_title: Tiger\n- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/teapot.jpg\n  example_title: Teapot\n- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/palace.jpg\n  example_title: Palace{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\n- Problem type: Image Regression\n\n## Validation Metrics\n\n{validation_metrics}\n'

def image_regression_metrics(pred):
    (raw_predictions, labels) = pred
    try:
        raw_predictions = [r for preds in raw_predictions for r in preds]
    except TypeError as err:
        if 'numpy.float32' not in str(err):
            raise Exception(err)
    pred_dict = {}
    metrics_to_calculate = {'mse': metrics.mean_squared_error, 'mae': metrics.mean_absolute_error, 'r2': metrics.r2_score, 'rmse': lambda y_true, y_pred: np.sqrt(metrics.mean_squared_error(y_true, y_pred)), 'explained_variance': metrics.explained_variance_score}
    for (key, func) in metrics_to_calculate.items():
        try:
            pred_dict[key] = float(func(labels, raw_predictions))
        except Exception:
            pred_dict[key] = -999
    return pred_dict

def process_data(train_data, valid_data, image_processor, config):
    if 'shortest_edge' in image_processor.size:
        size = image_processor.size['shortest_edge']
    else:
        size = (image_processor.size['height'], image_processor.size['width'])
    try:
        (height, width) = size
    except TypeError:
        height = size
        width = size
    train_transforms = A.Compose([A.RandomResizedCrop(height=height, width=width), A.RandomRotate90(), A.HorizontalFlip(p=0.5), A.RandomBrightnessContrast(p=0.2), A.Normalize(mean=image_processor.image_mean, std=image_processor.image_std)])
    val_transforms = A.Compose([A.Resize(height=height, width=width), A.Normalize(mean=image_processor.image_mean, std=image_processor.image_std)])
    train_data = ImageRegressionDataset(train_data, train_transforms, config)
    if valid_data is not None:
        valid_data = ImageRegressionDataset(valid_data, val_transforms, config)
        return (train_data, valid_data)
    return (train_data, None)

def create_model_card(config, trainer):
    if config.valid_split is not None:
        eval_scores = trainer.evaluate()
        eval_scores = [f"{k[len('eval_'):]}: {v}" for (k, v) in eval_scores.items() if k in VALID_METRICS]
        eval_scores = '\n\n'.join(eval_scores)
    else:
        eval_scores = 'No validation metrics available'
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, validation_metrics=eval_scores, base_model=base_model)
    return model_card

# File: autotrain-advanced-main/src/autotrain/trainers/object_detection/__main__.py
import argparse
import json
from functools import partial
from accelerate.state import PartialState
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from transformers import AutoConfig, AutoImageProcessor, AutoModelForObjectDetection, EarlyStoppingCallback, Trainer, TrainingArguments
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, monitor, pause_space, remove_autotrain_data, save_training_params
from autotrain.trainers.object_detection import utils
from autotrain.trainers.object_detection.params import ObjectDetectionParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = ObjectDetectionParams(**config)
    valid_data = None
    if config.data_path == f'{config.project_name}/autotrain-data':
        train_data = load_from_disk(config.data_path)[config.train_split]
    elif ':' in config.train_split:
        (dataset_config_name, split) = config.train_split.split(':')
        train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
    else:
        train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
    logger.info(f'Train data: {train_data}')
    logger.info(f'Valid data: {valid_data}')
    categories = train_data.features[config.objects_column].feature['category'].names
    id2label = dict(enumerate(categories))
    label2id = {v: k for (k, v) in id2label.items()}
    model_config = AutoConfig.from_pretrained(config.model, label2id=label2id, id2label=id2label, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token)
    try:
        model = AutoModelForObjectDetection.from_pretrained(config.model, config=model_config, ignore_mismatched_sizes=True, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token)
    except OSError:
        model = AutoModelForObjectDetection.from_pretrained(config.model, config=model_config, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True, from_tf=True)
    image_processor = AutoImageProcessor.from_pretrained(config.model, token=config.token, do_pad=False, do_resize=False, size={'longest_edge': config.image_square_size}, trust_remote_code=ALLOW_REMOTE_CODE)
    (train_data, valid_data) = utils.process_data(train_data, valid_data, image_processor, config)
    if config.logging_steps == -1:
        if config.valid_split is not None:
            logging_steps = int(0.2 * len(valid_data) / config.batch_size)
        else:
            logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=2 * config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False)
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    if config.valid_split is not None:
        training_args['eval_do_concat_batches'] = False
        early_stop = EarlyStoppingCallback(early_stopping_patience=config.early_stopping_patience, early_stopping_threshold=config.early_stopping_threshold)
        callbacks_to_use = [early_stop]
    else:
        callbacks_to_use = []
    callbacks_to_use.extend([UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()])
    _compute_metrics_fn = partial(utils.object_detection_metrics, image_processor=image_processor, id2label=id2label, threshold=0.0)
    args = TrainingArguments(**training_args)
    trainer_args = dict(args=args, model=model, callbacks=callbacks_to_use, data_collator=utils.collate_fn, tokenizer=image_processor, compute_metrics=_compute_metrics_fn)
    trainer = Trainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    logger.info('Finished training, saving model...')
    trainer.save_model(config.project_name)
    image_processor.save_pretrained(config.project_name)
    model_card = utils.create_model_card(config, trainer)
    with open(f'{config.project_name}/README.md', 'w') as f:
        f.write(model_card)
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            save_training_params(config)
            logger.info('Pushing model to hub...')
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)
if __name__ == '__main__':
    _args = parse_args()
    training_config = json.load(open(_args.training_config))
    _config = ObjectDetectionParams(**training_config)
    train(_config)

# File: autotrain-advanced-main/src/autotrain/trainers/object_detection/dataset.py
import numpy as np

class ObjectDetectionDataset:

    def __init__(self, data, transforms, image_processor, config):
        self.data = data
        self.transforms = transforms
        self.image_processor = image_processor
        self.config = config

    def __len__(self):
        return len(self.data)

    def __getitem__(self, item):
        image = self.data[item][self.config.image_column]
        objects = self.data[item][self.config.objects_column]
        output = self.transforms(image=np.array(image.convert('RGB')), bboxes=objects['bbox'], category=objects['category'])
        image = output['image']
        annotations = []
        for j in range(len(output['bboxes'])):
            annotations.append({'image_id': str(item), 'category_id': output['category'][j], 'iscrowd': 0, 'area': objects['bbox'][j][2] * objects['bbox'][j][3], 'bbox': output['bboxes'][j]})
        annotations = {'annotations': annotations, 'image_id': str(item)}
        result = self.image_processor(images=image, annotations=annotations, return_tensors='pt')
        result['pixel_values'] = result['pixel_values'][0]
        result['labels'] = result['labels'][0]
        return result

# File: autotrain-advanced-main/src/autotrain/trainers/object_detection/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class ObjectDetectionParams(AutoTrainParams):
    data_path: str = Field(None, title='Data path')
    model: str = Field('google/vit-base-patch16-224', title='Model name')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    lr: float = Field(5e-05, title='Learning rate')
    epochs: int = Field(3, title='Number of training epochs')
    batch_size: int = Field(8, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(1, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    seed: int = Field(42, title='Seed')
    train_split: str = Field('train', title='Train split')
    valid_split: Optional[str] = Field(None, title='Validation split')
    logging_steps: int = Field(-1, title='Logging steps')
    project_name: str = Field('project-name', title='Output directory')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    save_total_limit: int = Field(1, title='Save total limit')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    image_column: str = Field('image', title='Image column')
    objects_column: str = Field('objects', title='Target column')
    log: str = Field('none', title='Logging using experiment tracking')
    image_square_size: Optional[int] = Field(600, title='Image longest size will be resized to this value, then image will be padded to square.')
    early_stopping_patience: int = Field(5, title='Early stopping patience')
    early_stopping_threshold: float = Field(0.01, title='Early stopping threshold')

# File: autotrain-advanced-main/src/autotrain/trainers/object_detection/utils.py
import os
from dataclasses import dataclass
import albumentations as A
import torch
from torchmetrics.detection.mean_ap import MeanAveragePrecision
from transformers.image_transforms import center_to_corners_format
from autotrain.trainers.object_detection.dataset import ObjectDetectionDataset
VALID_METRICS = ('eval_loss', 'eval_map', 'eval_map_50', 'eval_map_75', 'eval_map_small', 'eval_map_medium', 'eval_map_large', 'eval_mar_1', 'eval_mar_10', 'eval_mar_100', 'eval_mar_small', 'eval_mar_medium', 'eval_mar_large')
MODEL_CARD = '\n---\ntags:\n- autotrain\n- object-detection\n- vision{base_model}\nwidget:\n- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg\n  example_title: Tiger\n- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/teapot.jpg\n  example_title: Teapot\n- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/palace.jpg\n  example_title: Palace{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\n- Problem type: Object Detection\n\n## Validation Metrics\n{validation_metrics}\n'

def collate_fn(batch):
    data = {}
    data['pixel_values'] = torch.stack([x['pixel_values'] for x in batch])
    data['labels'] = [x['labels'] for x in batch]
    if 'pixel_mask' in batch[0]:
        data['pixel_mask'] = torch.stack([x['pixel_mask'] for x in batch])
    return data

def process_data(train_data, valid_data, image_processor, config):
    max_size = image_processor.size['longest_edge']
    basic_transforms = [A.LongestMaxSize(max_size=max_size), A.PadIfNeeded(max_size, max_size, border_mode=0, value=(128, 128, 128), position='top_left')]
    train_transforms = A.Compose([A.Compose([A.SmallestMaxSize(max_size=max_size, p=1.0), A.RandomSizedBBoxSafeCrop(height=max_size, width=max_size, p=1.0)], p=0.2), A.OneOf([A.Blur(blur_limit=7, p=0.5), A.MotionBlur(blur_limit=7, p=0.5), A.Defocus(radius=(1, 5), alias_blur=(0.1, 0.25), p=0.1)], p=0.1), A.Perspective(p=0.1), A.HorizontalFlip(p=0.5), A.RandomBrightnessContrast(p=0.5), A.HueSaturationValue(p=0.1), *basic_transforms], bbox_params=A.BboxParams(format='coco', label_fields=['category'], clip=True, min_area=25))
    val_transforms = A.Compose(basic_transforms, bbox_params=A.BboxParams(format='coco', label_fields=['category'], clip=True))
    train_data = ObjectDetectionDataset(train_data, train_transforms, image_processor, config)
    if valid_data is not None:
        valid_data = ObjectDetectionDataset(valid_data, val_transforms, image_processor, config)
        return (train_data, valid_data)
    return (train_data, None)

def convert_bbox_yolo_to_pascal(boxes, image_size):
    boxes = center_to_corners_format(boxes)
    (height, width) = image_size
    boxes = boxes * torch.tensor([[width, height, width, height]])
    return boxes

@torch.no_grad()
def object_detection_metrics(evaluation_results, image_processor, threshold=0.0, id2label=None):

    @dataclass
    class ModelOutput:
        logits: torch.Tensor
        pred_boxes: torch.Tensor
    (predictions, targets) = (evaluation_results.predictions, evaluation_results.label_ids)
    image_sizes = []
    post_processed_targets = []
    post_processed_predictions = []
    for batch in targets:
        batch_image_sizes = torch.tensor([x['orig_size'] for x in batch])
        image_sizes.append(batch_image_sizes)
        for image_target in batch:
            boxes = torch.tensor(image_target['boxes'])
            boxes = convert_bbox_yolo_to_pascal(boxes, image_target['orig_size'])
            labels = torch.tensor(image_target['class_labels'])
            post_processed_targets.append({'boxes': boxes, 'labels': labels})
    for (batch, target_sizes) in zip(predictions, image_sizes):
        (batch_logits, batch_boxes) = (batch[1], batch[2])
        output = ModelOutput(logits=torch.tensor(batch_logits), pred_boxes=torch.tensor(batch_boxes))
        post_processed_output = image_processor.post_process_object_detection(output, threshold=threshold, target_sizes=target_sizes)
        post_processed_predictions.extend(post_processed_output)
    metric = MeanAveragePrecision(box_format='xyxy', class_metrics=True)
    metric.update(post_processed_predictions, post_processed_targets)
    metrics = metric.compute()
    classes = metrics.pop('classes')
    try:
        len(classes)
        calc_map_per_class = True
    except TypeError:
        calc_map_per_class = False
    if calc_map_per_class:
        map_per_class = metrics.pop('map_per_class')
        mar_100_per_class = metrics.pop('mar_100_per_class')
        for (class_id, class_map, class_mar) in zip(classes, map_per_class, mar_100_per_class):
            class_name = id2label[class_id.item()] if id2label is not None else class_id.item()
            metrics[f'map_{class_name}'] = class_map
            metrics[f'mar_100_{class_name}'] = class_mar
    metrics = {k: round(v.item(), 4) for (k, v) in metrics.items()}
    return metrics

def create_model_card(config, trainer):
    if config.valid_split is not None:
        eval_scores = trainer.evaluate()
        eval_scores = [f"{k[len('eval_'):]}: {v}" for (k, v) in eval_scores.items() if k in VALID_METRICS]
        eval_scores = '\n\n'.join(eval_scores)
    else:
        eval_scores = 'No validation metrics available'
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, validation_metrics=eval_scores, base_model=base_model)
    return model_card

# File: autotrain-advanced-main/src/autotrain/trainers/sent_transformers/__main__.py
import argparse
import json
from functools import partial
from accelerate import PartialState
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from sentence_transformers import SentenceTransformer, SentenceTransformerTrainer
from sentence_transformers.evaluation import EmbeddingSimilarityEvaluator, TripletEvaluator
from sentence_transformers.losses import CoSENTLoss, MultipleNegativesRankingLoss, SoftmaxLoss
from sentence_transformers.training_args import SentenceTransformerTrainingArguments
from transformers import EarlyStoppingCallback
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, monitor, pause_space, remove_autotrain_data, save_training_params
from autotrain.trainers.sent_transformers import utils
from autotrain.trainers.sent_transformers.params import SentenceTransformersParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = SentenceTransformersParams(**config)
    train_data = None
    valid_data = None
    if config.train_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            train_data = load_from_disk(config.data_path)[config.train_split]
        elif ':' in config.train_split:
            (dataset_config_name, split) = config.train_split.split(':')
            train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
    num_classes = None
    if config.trainer == 'pair_class':
        classes = train_data.features[config.target_column].names
        num_classes = len(classes)
        if num_classes < 2:
            raise ValueError('Invalid number of classes. Must be greater than 1.')
        if config.valid_split is not None:
            num_classes_valid = len(valid_data.unique(config.target_column))
            if num_classes_valid != num_classes:
                raise ValueError(f'Number of classes in train and valid are not the same. Training has {num_classes} and valid has {num_classes_valid}')
    if config.logging_steps == -1:
        logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    train_data = utils.process_columns(train_data, config)
    logger.info(f'Train data: {train_data}')
    if config.valid_split is not None:
        valid_data = utils.process_columns(valid_data, config)
        logger.info(f'Valid data: {valid_data}')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=2 * config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False)
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    if config.valid_split is not None:
        early_stop = EarlyStoppingCallback(early_stopping_patience=config.early_stopping_patience, early_stopping_threshold=config.early_stopping_threshold)
        callbacks_to_use = [early_stop]
    else:
        callbacks_to_use = []
    callbacks_to_use.extend([UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()])
    model = SentenceTransformer(config.model, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, model_kwargs={'ignore_mismatched_sizes': True})
    loss_mapping = {'pair': MultipleNegativesRankingLoss, 'pair_class': partial(SoftmaxLoss, sentence_embedding_dimension=model.get_sentence_embedding_dimension(), num_labels=num_classes), 'pair_score': CoSENTLoss, 'triplet': MultipleNegativesRankingLoss, 'qa': MultipleNegativesRankingLoss}
    evaluator = None
    if config.valid_split is not None:
        if config.trainer == 'pair_score':
            evaluator = EmbeddingSimilarityEvaluator(sentences1=valid_data['sentence1'], sentences2=valid_data['sentence2'], scores=valid_data['score'], name=config.valid_split)
        elif config.trainer == 'triplet':
            evaluator = TripletEvaluator(anchors=valid_data['anchor'], positives=valid_data['positive'], negatives=valid_data['negative'])
    logger.info('Setting up training arguments...')
    args = SentenceTransformerTrainingArguments(**training_args)
    trainer_args = dict(args=args, model=model, callbacks=callbacks_to_use)
    logger.info('Setting up trainer...')
    trainer = SentenceTransformerTrainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data, loss=loss_mapping[config.trainer], evaluator=evaluator)
    trainer.remove_callback(PrinterCallback)
    logger.info('Starting training...')
    trainer.train()
    logger.info('Finished training, saving model...')
    trainer.save_model(config.project_name)
    model_card = utils.create_model_card(config, trainer)
    with open(f'{config.project_name}/README.md', 'w') as f:
        f.write(model_card)
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            save_training_params(config)
            logger.info('Pushing model to hub...')
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)
if __name__ == '__main__':
    _args = parse_args()
    training_config = json.load(open(_args.training_config))
    _config = SentenceTransformersParams(**training_config)
    train(_config)

# File: autotrain-advanced-main/src/autotrain/trainers/sent_transformers/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class SentenceTransformersParams(AutoTrainParams):
    data_path: str = Field(None, title='Data path')
    model: str = Field('microsoft/mpnet-base', title='Model name')
    lr: float = Field(3e-05, title='Learning rate')
    epochs: int = Field(3, title='Number of training epochs')
    max_seq_length: int = Field(128, title='Max sequence length')
    batch_size: int = Field(8, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(1, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    seed: int = Field(42, title='Seed')
    train_split: str = Field('train', title='Train split')
    valid_split: Optional[str] = Field(None, title='Validation split')
    logging_steps: int = Field(-1, title='Logging steps')
    project_name: str = Field('project-name', title='Output directory')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    save_total_limit: int = Field(1, title='Save total limit')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    log: str = Field('none', title='Logging using experiment tracking')
    early_stopping_patience: int = Field(5, title='Early stopping patience')
    early_stopping_threshold: float = Field(0.01, title='Early stopping threshold')
    trainer: str = Field('pair_score', title='Trainer name')
    sentence1_column: str = Field('sentence1', title='Sentence 1 column')
    sentence2_column: str = Field('sentence2', title='Sentence 2 column')
    sentence3_column: Optional[str] = Field('sentence3', title='Sentence 3 column')
    target_column: Optional[str] = Field('target', title='Target column')

# File: autotrain-advanced-main/src/autotrain/trainers/sent_transformers/utils.py
import os
from autotrain import logger
MODEL_CARD = '\n---\nlibrary_name: sentence-transformers\ntags:\n- sentence-transformers\n- sentence-similarity\n- feature-extraction\n- autotrain{base_model}\nwidget:\n- source_sentence: \'search_query: i love autotrain\'\n  sentences:\n  - \'search_query: huggingface auto train\'\n  - \'search_query: hugging face auto train\'\n  - \'search_query: i love autotrain\'\npipeline_tag: sentence-similarity{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\n- Problem type: Sentence Transformers\n\n## Validation Metrics\n{validation_metrics}\n\n## Usage\n\n### Direct Usage (Sentence Transformers)\n\nFirst install the Sentence Transformers library:\n\n```bash\npip install -U sentence-transformers\n```\n\nThen you can load this model and run inference.\n```python\nfrom sentence_transformers import SentenceTransformer\n\n# Download from the Hugging Face Hub\nmodel = SentenceTransformer("sentence_transformers_model_id")\n# Run inference\nsentences = [\n    \'search_query: autotrain\',\n    \'search_query: auto train\',\n    \'search_query: i love autotrain\',\n]\nembeddings = model.encode(sentences)\nprint(embeddings.shape)\n\n# Get the similarity scores for the embeddings\nsimilarities = model.similarity(embeddings, embeddings)\nprint(similarities.shape)\n```\n'

def process_columns(data, config):
    if config.trainer == 'pair':
        if not (config.sentence1_column == 'anchor' and config.sentence1_column in data.column_names):
            data = data.rename_column(config.sentence1_column, 'anchor')
        if not (config.sentence2_column == 'positive' and config.sentence2_column in data.column_names):
            data = data.rename_column(config.sentence2_column, 'positive')
    elif config.trainer == 'pair_class':
        if not (config.sentence1_column == 'premise' and config.sentence1_column in data.column_names):
            data = data.rename_column(config.sentence1_column, 'premise')
        if not (config.sentence2_column == 'hypothesis' and config.sentence2_column in data.column_names):
            data = data.rename_column(config.sentence2_column, 'hypothesis')
        if not (config.target_column == 'label' and config.target_column in data.column_names):
            data = data.rename_column(config.target_column, 'label')
    elif config.trainer == 'pair_score':
        if not (config.sentence1_column == 'sentence1' and config.sentence1_column in data.column_names):
            data = data.rename_column(config.sentence1_column, 'sentence1')
        if not (config.sentence2_column == 'sentence2' and config.sentence2_column in data.column_names):
            data = data.rename_column(config.sentence2_column, 'sentence2')
        if not (config.target_column == 'score' and config.target_column in data.column_names):
            data = data.rename_column(config.target_column, 'score')
    elif config.trainer == 'triplet':
        if not (config.sentence1_column == 'anchor' and config.sentence1_column in data.column_names):
            data = data.rename_column(config.sentence1_column, 'anchor')
        if not (config.sentence2_column == 'positive' and config.sentence2_column in data.column_names):
            data = data.rename_column(config.sentence2_column, 'positive')
        if not (config.sentence3_column == 'negative' and config.sentence3_column in data.column_names):
            data = data.rename_column(config.sentence3_column, 'negative')
    elif config.trainer == 'qa':
        if not (config.sentence1_column == 'query' and config.sentence1_column in data.column_names):
            data = data.rename_column(config.sentence1_column, 'query')
        if not (config.sentence2_column == 'answer' and config.sentence2_column in data.column_names):
            data = data.rename_column(config.sentence2_column, 'answer')
    else:
        raise ValueError(f'Invalid trainer: {config.trainer}')
    return data

def create_model_card(config, trainer):
    if config.valid_split is not None:
        eval_scores = trainer.evaluate()
        logger.info(eval_scores)
        eval_scores = [f"{k[len('eval_'):]}: {v}" for (k, v) in eval_scores.items()]
        eval_scores = '\n\n'.join(eval_scores)
    else:
        eval_scores = 'No validation metrics available'
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, validation_metrics=eval_scores, base_model=base_model)
    return model_card

# File: autotrain-advanced-main/src/autotrain/trainers/seq2seq/__main__.py
import argparse
import json
from functools import partial
import torch
from accelerate.state import PartialState
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from peft import LoraConfig, TaskType, get_peft_model, prepare_model_for_kbit_training
from transformers import AutoConfig, AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig, DataCollatorForSeq2Seq, EarlyStoppingCallback, Seq2SeqTrainer, Seq2SeqTrainingArguments
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, monitor, pause_space, remove_autotrain_data, save_training_params
from autotrain.trainers.seq2seq import utils
from autotrain.trainers.seq2seq.dataset import Seq2SeqDataset
from autotrain.trainers.seq2seq.params import Seq2SeqParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = Seq2SeqParams(**config)
    train_data = None
    valid_data = None
    if config.train_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            train_data = load_from_disk(config.data_path)[config.train_split]
        elif ':' in config.train_split:
            (dataset_config_name, split) = config.train_split.split(':')
            train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
    tokenizer = AutoTokenizer.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    train_data = Seq2SeqDataset(data=train_data, tokenizer=tokenizer, config=config)
    if config.valid_split is not None:
        valid_data = Seq2SeqDataset(data=valid_data, tokenizer=tokenizer, config=config)
    if config.logging_steps == -1:
        if config.valid_split is not None:
            logging_steps = int(0.2 * len(valid_data) / config.batch_size)
        else:
            logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=2 * config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False, predict_with_generate=True, seed=config.seed)
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    if config.valid_split is not None:
        early_stop = EarlyStoppingCallback(early_stopping_patience=config.early_stopping_patience, early_stopping_threshold=config.early_stopping_threshold)
        callbacks_to_use = [early_stop]
    else:
        callbacks_to_use = []
    callbacks_to_use.extend([UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()])
    args = Seq2SeqTrainingArguments(**training_args)
    model_config = AutoConfig.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, use_cache=False)
    if config.peft:
        if config.quantization == 'int4':
            raise NotImplementedError('int4 quantization is not supported')
        if config.quantization == 'int8':
            bnb_config = BitsAndBytesConfig(load_in_8bit=True)
        else:
            bnb_config = None
        model = AutoModelForSeq2SeqLM.from_pretrained(config.model, config=model_config, token=config.token, quantization_config=bnb_config, trust_remote_code=ALLOW_REMOTE_CODE)
    else:
        model = AutoModelForSeq2SeqLM.from_pretrained(config.model, config=model_config, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    embedding_size = model.get_input_embeddings().weight.shape[0]
    if len(tokenizer) > embedding_size:
        model.resize_token_embeddings(len(tokenizer))
    if config.peft:
        target_modules = config.target_modules.split(',') if config.target_modules is not None else None
        if target_modules:
            target_modules = [module.strip() for module in target_modules]
        if len(target_modules) == 1 and target_modules[0] == 'all-linear':
            target_modules = 'all-linear'
        lora_config = LoraConfig(r=config.lora_r, lora_alpha=config.lora_alpha, target_modules=target_modules, lora_dropout=config.lora_dropout, bias='none', task_type=TaskType.SEQ_2_SEQ_LM)
        if config.quantization is not None:
            model = prepare_model_for_kbit_training(model)
        model = get_peft_model(model, lora_config)
    _s2s_metrics = partial(utils._seq2seq_metrics, tokenizer=tokenizer)
    trainer_args = dict(args=args, model=model, callbacks=callbacks_to_use, compute_metrics=_s2s_metrics)
    data_collator = DataCollatorForSeq2Seq(tokenizer, model=model)
    trainer = Seq2SeqTrainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data, data_collator=data_collator, tokenizer=tokenizer)
    for (name, module) in trainer.model.named_modules():
        if 'norm' in name:
            module = module.to(torch.float32)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    logger.info('Finished training, saving model...')
    trainer.model.config.use_cache = True
    trainer.save_model(config.project_name)
    model_card = utils.create_model_card(config, trainer)
    with open(f'{config.project_name}/README.md', 'w', encoding='utf-8') as f:
        f.write(model_card)
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            save_training_params(config)
            logger.info('Pushing model to hub...')
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)
if __name__ == '__main__':
    _args = parse_args()
    training_config = json.load(open(_args.training_config))
    config = Seq2SeqParams(**training_config)
    train(config)

# File: autotrain-advanced-main/src/autotrain/trainers/seq2seq/dataset.py
class Seq2SeqDataset:

    def __init__(self, data, tokenizer, config):
        self.data = data
        self.tokenizer = tokenizer
        self.config = config
        self.max_len_input = self.config.max_seq_length
        self.max_len_target = self.config.max_target_length

    def __len__(self):
        return len(self.data)

    def __getitem__(self, item):
        text = str(self.data[item][self.config.text_column])
        target = str(self.data[item][self.config.target_column])
        model_inputs = self.tokenizer(text, max_length=self.max_len_input, truncation=True)
        labels = self.tokenizer(text_target=target, max_length=self.max_len_target, truncation=True)
        model_inputs['labels'] = labels['input_ids']
        return model_inputs

# File: autotrain-advanced-main/src/autotrain/trainers/seq2seq/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class Seq2SeqParams(AutoTrainParams):
    data_path: str = Field(None, title='Data path')
    model: str = Field('google/flan-t5-base', title='Model name')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    seed: int = Field(42, title='Seed')
    train_split: str = Field('train', title='Train split')
    valid_split: Optional[str] = Field(None, title='Validation split')
    project_name: str = Field('project-name', title='Output directory')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    text_column: str = Field('text', title='Text column')
    target_column: str = Field('target', title='Target text column')
    lr: float = Field(5e-05, title='Learning rate')
    epochs: int = Field(3, title='Number of training epochs')
    max_seq_length: int = Field(128, title='Max sequence length')
    max_target_length: int = Field(128, title='Max target sequence length')
    batch_size: int = Field(2, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(1, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    logging_steps: int = Field(-1, title='Logging steps')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    save_total_limit: int = Field(1, title='Save total limit')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    peft: bool = Field(False, title='Use PEFT')
    quantization: Optional[str] = Field('int8', title='int4, int8, or None')
    lora_r: int = Field(16, title='LoRA-R')
    lora_alpha: int = Field(32, title='LoRA-Alpha')
    lora_dropout: float = Field(0.05, title='LoRA-Dropout')
    target_modules: str = Field('all-linear', title='Target modules for PEFT')
    log: str = Field('none', title='Logging using experiment tracking')
    early_stopping_patience: int = Field(5, title='Early stopping patience')
    early_stopping_threshold: float = Field(0.01, title='Early stopping threshold')

# File: autotrain-advanced-main/src/autotrain/trainers/seq2seq/utils.py
import os
import evaluate
import nltk
import numpy as np
ROUGE_METRIC = evaluate.load('rouge')
MODEL_CARD = '\n---\ntags:\n- autotrain\n- text2text-generation{base_model}\nwidget:\n- text: "I love AutoTrain"{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\n- Problem type: Seq2Seq\n\n## Validation Metrics\n{validation_metrics}\n'

def _seq2seq_metrics(pred, tokenizer):
    (predictions, labels) = pred
    decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True)
    labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
    decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
    decoded_preds = ['\n'.join(nltk.sent_tokenize(pred.strip())) for pred in decoded_preds]
    decoded_labels = ['\n'.join(nltk.sent_tokenize(label.strip())) for label in decoded_labels]
    result = ROUGE_METRIC.compute(predictions=decoded_preds, references=decoded_labels, use_stemmer=True)
    result = {key: value * 100 for (key, value) in result.items()}
    prediction_lens = [np.count_nonzero(pred != tokenizer.pad_token_id) for pred in predictions]
    result['gen_len'] = np.mean(prediction_lens)
    return {k: round(v, 4) for (k, v) in result.items()}

def create_model_card(config, trainer):
    if config.valid_split is not None:
        eval_scores = trainer.evaluate()
        eval_scores = [f"{k[len('eval_'):]}: {v}" for (k, v) in eval_scores.items()]
        eval_scores = '\n\n'.join(eval_scores)
    else:
        eval_scores = 'No validation metrics available'
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, validation_metrics=eval_scores, base_model=base_model)
    return model_card

# File: autotrain-advanced-main/src/autotrain/trainers/tabular/__main__.py
import argparse
import json
import os
from functools import partial
import joblib
import numpy as np
import optuna
import pandas as pd
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from sklearn import pipeline, preprocessing
from sklearn.compose import ColumnTransformer
from autotrain import logger
from autotrain.trainers.common import monitor, pause_space, remove_autotrain_data, save_training_params
from autotrain.trainers.tabular import utils
from autotrain.trainers.tabular.params import TabularParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

def optimize(trial, model_name, xtrain, xvalid, ytrain, yvalid, eval_metric, task, preprocessor):
    if isinstance(trial, dict):
        params = trial
    else:
        params = utils.get_params(trial, model_name, task)
    labels = None
    if task == 'multi_class_classification':
        labels = np.unique(ytrain)
    metrics = utils.TabularMetrics(sub_task=task, labels=labels)
    if task in ('binary_classification', 'multi_class_classification', 'single_column_regression'):
        ytrain = ytrain.ravel()
        yvalid = yvalid.ravel()
    if preprocessor is not None:
        try:
            xtrain = preprocessor.fit_transform(xtrain)
            xvalid = preprocessor.transform(xvalid)
        except ValueError:
            logger.info('Preprocessing failed, using nan_to_num')
            train_cols = xtrain.columns.tolist()
            valid_cols = xvalid.columns.tolist()
            xtrain = np.nan_to_num(xtrain)
            xvalid = np.nan_to_num(xvalid)
            xtrain = pd.DataFrame(xtrain, columns=train_cols)
            xvalid = pd.DataFrame(xvalid, columns=valid_cols)
            xtrain = preprocessor.fit_transform(xtrain)
            xvalid = preprocessor.transform(xvalid)
    if model_name == 'xgboost':
        params['eval_metric'] = eval_metric
    _model = utils.TabularModel(model_name, preprocessor=None, sub_task=task, params=params)
    model = _model.pipeline
    models = []
    if task in ('multi_label_classification', 'multi_column_regression'):
        ypred = []
        models = [model] * ytrain.shape[1]
        for (idx, _m) in enumerate(models):
            if model_name == 'xgboost':
                _m.fit(xtrain, ytrain[:, idx], model__eval_set=[(xvalid, yvalid[:, idx])], model__verbose=False)
            else:
                _m.fit(xtrain, ytrain[:, idx])
            if task == 'multi_column_regression':
                ypred_temp = _m.predict(xvalid)
            elif _model.use_predict_proba:
                ypred_temp = _m.predict_proba(xvalid)[:, 1]
            else:
                ypred_temp = _m.predict(xvalid)
            ypred.append(ypred_temp)
        ypred = np.column_stack(ypred)
    else:
        models = [model]
        if model_name == 'xgboost':
            model.fit(xtrain, ytrain, model__eval_set=[(xvalid, yvalid)], model__verbose=False)
        else:
            models[0].fit(xtrain, ytrain)
        if _model.use_predict_proba:
            ypred = models[0].predict_proba(xvalid)
        else:
            ypred = models[0].predict(xvalid)
        if task == 'multi_class_classification':
            if ypred.reshape(xvalid.shape[0], -1).shape[1] != len(labels):
                ypred_ohe = np.zeros((xvalid.shape[0], len(labels)))
                ypred_ohe[np.arange(xvalid.shape[0]), ypred] = 1
                ypred = ypred_ohe
        if task == 'binary_classification':
            if ypred.reshape(xvalid.shape[0], -1).shape[1] != 2:
                ypred = np.column_stack([1 - ypred, ypred])
    metric_dict = metrics.calculate(yvalid, ypred)
    if eval_metric in metric_dict:
        metric_dict['loss'] = metric_dict[eval_metric]
    logger.info(f'Metrics: {metric_dict}')
    if isinstance(trial, dict):
        return (models, preprocessor, metric_dict)
    return metric_dict['loss']

@monitor
def train(config):
    if isinstance(config, dict):
        config = TabularParams(**config)
    logger.info('Starting training...')
    logger.info(f'Training config: {config}')
    train_data = None
    valid_data = None
    if config.data_path == f'{config.project_name}/autotrain-data':
        logger.info('loading dataset from disk')
        train_data = load_from_disk(config.data_path)[config.train_split]
    elif ':' in config.train_split:
        (dataset_config_name, split) = config.train_split.split(':')
        train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
    else:
        train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    train_data = train_data.to_pandas()
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
        valid_data = valid_data.to_pandas()
    if valid_data is None:
        raise Exception('valid_data is None. Please provide a valid_split for tabular training.')
    if config.categorical_columns is None:
        config.categorical_columns = utils.get_categorical_columns(train_data)
    if config.numerical_columns is None:
        config.numerical_columns = utils.get_numerical_columns(train_data)
    _id_target_cols = [config.id_column] + config.target_columns if config.id_column is not None else config.target_columns
    config.numerical_columns = [c for c in config.numerical_columns if c not in _id_target_cols]
    config.categorical_columns = [c for c in config.categorical_columns if c not in _id_target_cols]
    useful_columns = config.categorical_columns + config.numerical_columns
    logger.info(f'Categorical columns: {config.categorical_columns}')
    logger.info(f'Numerical columns: {config.numerical_columns}')
    for col in config.categorical_columns:
        train_data[col] = train_data[col].astype('category')
        valid_data[col] = valid_data[col].astype('category')
    logger.info(f'Useful columns: {useful_columns}')
    target_encoders = {}
    if config.task == 'classification':
        for target_column in config.target_columns:
            target_encoder = preprocessing.LabelEncoder()
            target_encoder.fit(train_data[target_column])
            target_encoders[target_column] = target_encoder
    for (k, v) in target_encoders.items():
        train_data.loc[:, k] = v.transform(train_data[k])
        valid_data.loc[:, k] = v.transform(valid_data[k])
    numeric_transformer = 'passthrough'
    categorical_transformer = 'passthrough'
    transformers = []
    preprocessor = None
    numeric_steps = []
    imputer = utils.get_imputer(config.numerical_imputer)
    scaler = utils.get_scaler(config.numeric_scaler)
    if imputer is not None:
        numeric_steps.append(('num_imputer', imputer))
    if scaler is not None:
        numeric_steps.append(('num_scaler', scaler))
    if len(numeric_steps) > 0:
        numeric_transformer = pipeline.Pipeline(numeric_steps)
        transformers.append(('numeric', numeric_transformer, config.numerical_columns))
    categorical_steps = []
    imputer = utils.get_imputer(config.categorical_imputer)
    if imputer is not None:
        categorical_steps.append(('cat_imputer', imputer))
    if len(config.categorical_columns) > 0:
        if config.model in ('xgboost', 'lightgbm', 'randomforest', 'catboost', 'extratrees'):
            categorical_steps.append(('cat_encoder', preprocessing.OrdinalEncoder(handle_unknown='use_encoded_value', categories='auto', unknown_value=np.nan)))
        else:
            categorical_steps.append(('cat_encoder', preprocessing.OneHotEncoder(handle_unknown='ignore')))
    if len(categorical_steps) > 0:
        categorical_transformer = pipeline.Pipeline(categorical_steps)
        transformers.append(('categorical', categorical_transformer, config.categorical_columns))
    if len(transformers) > 0:
        preprocessor = ColumnTransformer(transformers=transformers, verbose=True, n_jobs=-1)
        logger.info(f'Preprocessor: {preprocessor}')
    xtrain = train_data[useful_columns].reset_index(drop=True)
    xvalid = valid_data[useful_columns].reset_index(drop=True)
    ytrain = train_data[config.target_columns].values
    yvalid = valid_data[config.target_columns].values
    if config.task == 'classification':
        if len(target_encoders) == 1:
            if len(target_encoders[config.target_columns[0]].classes_) == 2:
                sub_task = 'binary_classification'
            else:
                sub_task = 'multi_class_classification'
        else:
            sub_task = 'multi_label_classification'
    elif len(config.target_columns) > 1:
        sub_task = 'multi_column_regression'
    else:
        sub_task = 'single_column_regression'
    (eval_metric, direction) = utils.get_metric_direction(sub_task)
    logger.info(f'Sub task: {sub_task}')
    args = {'model_name': config.model, 'xtrain': xtrain, 'xvalid': xvalid, 'ytrain': ytrain, 'yvalid': yvalid, 'eval_metric': eval_metric, 'task': sub_task, 'preprocessor': preprocessor}
    optimize_func = partial(optimize, **args)
    study = optuna.create_study(direction=direction, study_name='AutoTrain')
    study.optimize(optimize_func, n_trials=config.num_trials, timeout=config.time_limit)
    best_params = study.best_params
    logger.info(f'Best params: {best_params}')
    (best_models, best_preprocessors, best_metrics) = optimize(best_params, **args)
    models = [pipeline.Pipeline([('preprocessor', best_preprocessors), ('model', m)]) for m in best_models] if best_preprocessors is not None else best_models
    joblib.dump(models[0] if len(models) == 1 else models, os.path.join(config.project_name, 'model.joblib'))
    joblib.dump(target_encoders, os.path.join(config.project_name, 'target_encoders.joblib'))
    model_card = utils.create_model_card(config, sub_task, best_params, best_metrics)
    if model_card is not None:
        with open(os.path.join(config.project_name, 'README.md'), 'w') as fp:
            fp.write(f'{model_card}')
    if os.path.exists(f'{config.project_name}/training_params.json'):
        training_params = json.load(open(f'{config.project_name}/training_params.json'))
        training_params.pop('token')
        json.dump(training_params, open(f'{config.project_name}/training_params.json', 'w'))
    with open(f'{config.project_name}/README.md', 'w') as f:
        f.write(model_card)
    if config.push_to_hub:
        remove_autotrain_data(config)
        save_training_params(config)
        logger.info('Pushing model to hub...')
        api = HfApi(token=config.token)
        api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True)
        api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    pause_space(config)
if __name__ == '__main__':
    args = parse_args()
    training_config = json.load(open(args.training_config))
    config = TabularParams(**training_config)
    train(config)

# File: autotrain-advanced-main/src/autotrain/trainers/tabular/params.py
from typing import List, Optional, Union
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class TabularParams(AutoTrainParams):
    data_path: str = Field(None, title='Data path')
    model: str = Field('xgboost', title='Model name')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    seed: int = Field(42, title='Seed')
    train_split: str = Field('train', title='Train split')
    valid_split: Optional[str] = Field(None, title='Validation split')
    project_name: str = Field('project-name', title='Output directory')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    id_column: str = Field('id', title='ID column')
    target_columns: Union[List[str], str] = Field(['target'], title='Target column(s)')
    categorical_columns: Optional[List[str]] = Field(None, title='Categorical columns')
    numerical_columns: Optional[List[str]] = Field(None, title='Numerical columns')
    task: str = Field('classification', title='Task')
    num_trials: int = Field(10, title='Number of trials')
    time_limit: int = Field(600, title='Time limit')
    categorical_imputer: Optional[str] = Field(None, title='Categorical imputer')
    numerical_imputer: Optional[str] = Field(None, title='Numerical imputer')
    numeric_scaler: Optional[str] = Field(None, title='Numeric scaler')

# File: autotrain-advanced-main/src/autotrain/trainers/tabular/utils.py
import copy
from collections import defaultdict
from dataclasses import dataclass
from functools import partial
from typing import List, Optional
import numpy as np
from sklearn import ensemble, impute, linear_model
from sklearn import metrics as skmetrics
from sklearn import naive_bayes, neighbors, pipeline, preprocessing, svm, tree
from xgboost import XGBClassifier, XGBRegressor
MARKDOWN = '\n---\ntags:\n- autotrain\n- tabular\n- {task}\n- tabular-{task}\ndatasets:\n- {dataset}\n---\n\n# Model Trained Using AutoTrain\n\n- Problem type: Tabular {task}\n\n## Validation Metrics\n\n{metrics}\n\n## Best Params\n\n{params}\n\n## Usage\n\n```python\nimport json\nimport joblib\nimport pandas as pd\n\nmodel = joblib.load(\'model.joblib\')\nconfig = json.load(open(\'config.json\'))\n\nfeatures = config[\'features\']\n\n# data = pd.read_csv("data.csv")\ndata = data[features]\n\npredictions = model.predict(data)  # or model.predict_proba(data)\n\n# predictions can be converted to original labels using label_encoders.pkl\n\n```\n'
_MODELS: dict = defaultdict(dict)
_MODELS['xgboost']['classification'] = XGBClassifier
_MODELS['xgboost']['regression'] = XGBRegressor
_MODELS['logistic_regression']['classification'] = linear_model.LogisticRegression
_MODELS['logistic_regression']['regression'] = linear_model.LogisticRegression
_MODELS['random_forest']['classification'] = ensemble.RandomForestClassifier
_MODELS['random_forest']['regression'] = ensemble.RandomForestRegressor
_MODELS['extra_trees']['classification'] = ensemble.ExtraTreesClassifier
_MODELS['extra_trees']['regression'] = ensemble.ExtraTreesRegressor
_MODELS['gradient_boosting']['classification'] = ensemble.GradientBoostingClassifier
_MODELS['gradient_boosting']['regression'] = ensemble.GradientBoostingRegressor
_MODELS['adaboost']['classification'] = ensemble.AdaBoostClassifier
_MODELS['adaboost']['regression'] = ensemble.AdaBoostRegressor
_MODELS['ridge']['classification'] = linear_model.RidgeClassifier
_MODELS['ridge']['regression'] = linear_model.Ridge
_MODELS['svm']['classification'] = svm.LinearSVC
_MODELS['svm']['regression'] = svm.LinearSVR
_MODELS['decision_tree']['classification'] = tree.DecisionTreeClassifier
_MODELS['decision_tree']['regression'] = tree.DecisionTreeRegressor
_MODELS['lasso']['regression'] = linear_model.Lasso
_MODELS['linear_regression']['regression'] = linear_model.LinearRegression
_MODELS['naive_bayes']['classification'] = naive_bayes.GaussianNB
_MODELS['knn']['classification'] = neighbors.KNeighborsClassifier
_MODELS['knn']['regression'] = neighbors.KNeighborsRegressor
CLASSIFICATION_TASKS = ('binary_classification', 'multi_class_classification', 'multi_label_classification')
REGRESSION_TASKS = ('single_column_regression', 'multi_column_regression')

@dataclass
class TabularMetrics:
    sub_task: str
    labels: Optional[List] = None

    def __post_init__(self):
        if self.sub_task == 'binary_classification':
            self.valid_metrics = {'auc': skmetrics.roc_auc_score, 'logloss': skmetrics.log_loss, 'f1': skmetrics.f1_score, 'accuracy': skmetrics.accuracy_score, 'precision': skmetrics.precision_score, 'recall': skmetrics.recall_score}
        elif self.sub_task == 'multi_class_classification':
            self.valid_metrics = {'logloss': partial(skmetrics.log_loss, labels=self.labels), 'accuracy': skmetrics.accuracy_score, 'mlogloss': partial(skmetrics.log_loss, labels=self.labels), 'f1_macro': partial(skmetrics.f1_score, average='macro', labels=self.labels), 'f1_micro': partial(skmetrics.f1_score, average='micro', labels=self.labels), 'f1_weighted': partial(skmetrics.f1_score, average='weighted', labels=self.labels), 'precision_macro': partial(skmetrics.precision_score, average='macro', labels=self.labels), 'precision_micro': partial(skmetrics.precision_score, average='micro', labels=self.labels), 'precision_weighted': partial(skmetrics.precision_score, average='weighted', labels=self.labels), 'recall_macro': partial(skmetrics.recall_score, average='macro', labels=self.labels), 'recall_micro': partial(skmetrics.recall_score, average='micro', labels=self.labels), 'recall_weighted': partial(skmetrics.recall_score, average='weighted', labels=self.labels)}
        elif self.sub_task in ('single_column_regression', 'multi_column_regression'):
            self.valid_metrics = {'r2': skmetrics.r2_score, 'mse': skmetrics.mean_squared_error, 'mae': skmetrics.mean_absolute_error, 'rmse': partial(skmetrics.mean_squared_error, squared=False), 'rmsle': partial(skmetrics.mean_squared_log_error, squared=False)}
        elif self.sub_task == 'multi_label_classification':
            self.valid_metrics = {'logloss': skmetrics.log_loss}
        else:
            raise ValueError('Invalid problem type')

    def calculate(self, y_true, y_pred):
        metrics = {}
        for (metric_name, metric_func) in self.valid_metrics.items():
            if self.sub_task == 'binary_classification':
                if metric_name == 'auc':
                    metrics[metric_name] = metric_func(y_true, y_pred[:, 1])
                elif metric_name == 'logloss':
                    metrics[metric_name] = metric_func(y_true, y_pred)
                else:
                    metrics[metric_name] = metric_func(y_true, y_pred[:, 1] >= 0.5)
            elif self.sub_task == 'multi_class_classification':
                if metric_name in ('accuracy', 'f1_macro', 'f1_micro', 'f1_weighted', 'precision_macro', 'precision_micro', 'precision_weighted', 'recall_macro', 'recall_micro', 'recall_weighted'):
                    metrics[metric_name] = metric_func(y_true, np.argmax(y_pred, axis=1))
                else:
                    metrics[metric_name] = metric_func(y_true, y_pred)
            elif metric_name == 'rmsle':
                temp_pred = copy.deepcopy(y_pred)
                temp_pred = np.clip(temp_pred, 0, None)
                metrics[metric_name] = metric_func(y_true, temp_pred)
            else:
                metrics[metric_name] = metric_func(y_true, y_pred)
        return metrics

class TabularModel:

    def __init__(self, model, preprocessor, sub_task, params):
        self.model = model
        self.preprocessor = preprocessor
        self.sub_task = sub_task
        self.params = params
        self.use_predict_proba = True
        _model = self._get_model()
        if self.preprocessor is not None:
            self.pipeline = pipeline.Pipeline([('preprocessor', self.preprocessor), ('model', _model)])
        else:
            self.pipeline = pipeline.Pipeline([('model', _model)])

    def _get_model(self):
        if self.model in _MODELS:
            if self.sub_task in CLASSIFICATION_TASKS:
                if self.model in ('svm', 'ridge'):
                    self.use_predict_proba = False
                return _MODELS[self.model]['classification'](**self.params)
            elif self.sub_task in REGRESSION_TASKS:
                self.use_predict_proba = False
                return _MODELS[self.model]['regression'](**self.params)
            else:
                raise ValueError('Invalid task')
        else:
            raise ValueError('Invalid model')

def get_params(trial, model, task):
    if model == 'xgboost':
        params = {'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.25, log=True), 'reg_lambda': trial.suggest_float('reg_lambda', 1e-08, 100.0, log=True), 'reg_alpha': trial.suggest_float('reg_alpha', 1e-08, 100.0, log=True), 'subsample': trial.suggest_float('subsample', 0.1, 1.0), 'colsample_bytree': trial.suggest_float('colsample_bytree', 0.1, 1.0), 'max_depth': trial.suggest_int('max_depth', 1, 9), 'early_stopping_rounds': trial.suggest_int('early_stopping_rounds', 100, 500), 'n_estimators': trial.suggest_categorical('n_estimators', [7000, 15000, 20000]), 'tree_method': 'hist', 'random_state': 42}
        return params
    if model == 'logistic_regression':
        if task in CLASSIFICATION_TASKS:
            params = {'C': trial.suggest_float('C', 1e-08, 1000.0, log=True), 'fit_intercept': trial.suggest_categorical('fit_intercept', [True, False]), 'solver': trial.suggest_categorical('solver', ['liblinear', 'saga']), 'penalty': trial.suggest_categorical('penalty', ['l1', 'l2']), 'n_jobs': -1}
            return params
        raise ValueError('Task not supported')
    if model == 'random_forest':
        params = {'n_estimators': trial.suggest_int('n_estimators', 10, 10000), 'max_depth': trial.suggest_int('max_depth', 2, 15), 'max_features': trial.suggest_categorical('max_features', ['auto', 'sqrt', 'log2', None]), 'min_samples_split': trial.suggest_int('min_samples_split', 2, 20), 'min_samples_leaf': trial.suggest_int('min_samples_leaf', 1, 20), 'bootstrap': trial.suggest_categorical('bootstrap', [True, False]), 'n_jobs': -1}
        if task in CLASSIFICATION_TASKS:
            params['criterion'] = trial.suggest_categorical('criterion', ['gini', 'entropy'])
            return params
        if task in REGRESSION_TASKS:
            params['criterion'] = trial.suggest_categorical('criterion', ['squared_error', 'absolute_error', 'poisson'])
            return params
        raise ValueError('Task not supported')
    if model == 'extra_trees':
        params = {'n_estimators': trial.suggest_int('n_estimators', 10, 10000), 'max_depth': trial.suggest_int('max_depth', 2, 15), 'max_features': trial.suggest_categorical('max_features', ['auto', 'sqrt', 'log2', None]), 'min_samples_split': trial.suggest_int('min_samples_split', 2, 20), 'min_samples_leaf': trial.suggest_int('min_samples_leaf', 1, 20), 'bootstrap': trial.suggest_categorical('bootstrap', [True, False]), 'n_jobs': -1}
        if task in CLASSIFICATION_TASKS:
            params['criterion'] = trial.suggest_categorical('criterion', ['gini', 'entropy'])
            return params
        if task in REGRESSION_TASKS:
            params['criterion'] = trial.suggest_categorical('criterion', ['squared_error', 'absolute_error'])
            return params
        raise ValueError('Task not supported')
    if model == 'decision_tree':
        params = {'max_depth': trial.suggest_int('max_depth', 1, 15), 'min_samples_split': trial.suggest_int('min_samples_split', 2, 20), 'min_samples_leaf': trial.suggest_int('min_samples_leaf', 1, 20), 'max_features': trial.suggest_categorical('max_features', ['auto', 'sqrt', 'log2', None]), 'splitter': trial.suggest_categorical('splitter', ['best', 'random'])}
        if task in CLASSIFICATION_TASKS:
            params['criterion'] = trial.suggest_categorical('criterion', ['gini', 'entropy'])
            return params
        if task in REGRESSION_TASKS:
            params['criterion'] = trial.suggest_categorical('criterion', ['squared_error', 'absolute_error', 'friedman_mse', 'poisson'])
            return params
        raise ValueError('Task not supported')
    if model == 'linear_regression':
        if task in REGRESSION_TASKS:
            params = {'fit_intercept': trial.suggest_categorical('fit_intercept', [True, False])}
            return params
        raise ValueError('Task not supported')
    if model == 'svm':
        if task in CLASSIFICATION_TASKS:
            params = {'C': trial.suggest_float('C', 1e-08, 1000.0, log=True), 'fit_intercept': trial.suggest_categorical('fit_intercept', [True, False]), 'penalty': 'l2', 'max_iter': trial.suggest_int('max_iter', 1000, 10000)}
            return params
        if task in REGRESSION_TASKS:
            params = {'C': trial.suggest_float('C', 1e-08, 1000.0, log=True), 'fit_intercept': trial.suggest_categorical('fit_intercept', [True, False]), 'loss': trial.suggest_categorical('loss', ['epsilon_insensitive', 'squared_epsilon_insensitive']), 'epsilon': trial.suggest_float('epsilon', 1e-08, 0.1, log=True), 'max_iter': trial.suggest_int('max_iter', 1000, 10000)}
            return params
        raise ValueError('Task not supported')
    if model == 'ridge':
        params = {'alpha': trial.suggest_float('alpha', 1e-08, 1000.0, log=True), 'fit_intercept': trial.suggest_categorical('fit_intercept', [True, False]), 'max_iter': trial.suggest_int('max_iter', 1000, 10000)}
        if task in CLASSIFICATION_TASKS:
            return params
        if task in REGRESSION_TASKS:
            return params
        raise ValueError('Task not supported')
    if model == 'lasso':
        if task in REGRESSION_TASKS:
            params = {'alpha': trial.suggest_float('alpha', 1e-08, 1000.0, log=True), 'fit_intercept': trial.suggest_categorical('fit_intercept', [True, False]), 'max_iter': trial.suggest_int('max_iter', 1000, 10000)}
            return params
        raise ValueError('Task not supported')
    if model == 'knn':
        params = {'n_neighbors': trial.suggest_int('n_neighbors', 1, 25), 'weights': trial.suggest_categorical('weights', ['uniform', 'distance']), 'algorithm': trial.suggest_categorical('algorithm', ['ball_tree', 'kd_tree', 'brute']), 'leaf_size': trial.suggest_int('leaf_size', 1, 100), 'p': trial.suggest_categorical('p', [1, 2]), 'metric': trial.suggest_categorical('metric', ['minkowski', 'euclidean', 'manhattan'])}
        if task in CLASSIFICATION_TASKS or task in REGRESSION_TASKS:
            return params
        raise ValueError('Task not supported')
    return ValueError('Invalid model')

def get_imputer(imputer_name):
    if imputer_name is None:
        return None
    if imputer_name == 'median':
        return impute.SimpleImputer(strategy='median')
    if imputer_name == 'mean':
        return impute.SimpleImputer(strategy='mean')
    if imputer_name == 'most_frequent':
        return impute.SimpleImputer(strategy='most_frequent')
    raise ValueError('Invalid imputer')

def get_scaler(scaler_name):
    if scaler_name is None:
        return None
    if scaler_name == 'standard':
        return preprocessing.StandardScaler()
    if scaler_name == 'minmax':
        return preprocessing.MinMaxScaler()
    if scaler_name == 'robust':
        return preprocessing.RobustScaler()
    if scaler_name == 'normal':
        return preprocessing.Normalizer()
    raise ValueError('Invalid scaler')

def get_metric_direction(sub_task):
    if sub_task == 'binary_classification':
        return ('logloss', 'minimize')
    if sub_task == 'multi_class_classification':
        return ('mlogloss', 'minimize')
    if sub_task == 'single_column_regression':
        return ('rmse', 'minimize')
    if sub_task == 'multi_label_classification':
        return ('logloss', 'minimize')
    if sub_task == 'multi_column_regression':
        return ('rmse', 'minimize')
    raise ValueError('Invalid sub_task')

def get_categorical_columns(df):
    return list(df.select_dtypes(include=['category', 'object']).columns)

def get_numerical_columns(df):
    return list(df.select_dtypes(include=['number']).columns)

def create_model_card(config, sub_task, best_params, best_metrics):
    best_metrics = '\n'.join([f'- {k}: {v}' for (k, v) in best_metrics.items()])
    best_params = '\n'.join([f'- {k}: {v}' for (k, v) in best_params.items()])
    return MARKDOWN.format(task=config.task, dataset=config.data_path, metrics=best_metrics, params=best_params)

# File: autotrain-advanced-main/src/autotrain/trainers/text_classification/__main__.py
import argparse
import json
from accelerate.state import PartialState
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from transformers import AutoConfig, AutoModelForSequenceClassification, AutoTokenizer, EarlyStoppingCallback, Trainer, TrainingArguments
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, monitor, pause_space, remove_autotrain_data, save_training_params
from autotrain.trainers.text_classification import utils
from autotrain.trainers.text_classification.dataset import TextClassificationDataset
from autotrain.trainers.text_classification.params import TextClassificationParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = TextClassificationParams(**config)
    train_data = None
    valid_data = None
    if config.train_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            train_data = load_from_disk(config.data_path)[config.train_split]
        elif ':' in config.train_split:
            (dataset_config_name, split) = config.train_split.split(':')
            train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
    classes = train_data.features[config.target_column].names
    label2id = {c: i for (i, c) in enumerate(classes)}
    num_classes = len(classes)
    if num_classes < 2:
        raise ValueError('Invalid number of classes. Must be greater than 1.')
    if config.valid_split is not None:
        num_classes_valid = len(valid_data.unique(config.target_column))
        if num_classes_valid != num_classes:
            raise ValueError(f'Number of classes in train and valid are not the same. Training has {num_classes} and valid has {num_classes_valid}')
    model_config = AutoConfig.from_pretrained(config.model, num_labels=num_classes)
    model_config._num_labels = len(label2id)
    model_config.label2id = label2id
    model_config.id2label = {v: k for (k, v) in label2id.items()}
    try:
        model = AutoModelForSequenceClassification.from_pretrained(config.model, config=model_config, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    except OSError:
        model = AutoModelForSequenceClassification.from_pretrained(config.model, config=model_config, from_tf=True, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    tokenizer = AutoTokenizer.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    train_data = TextClassificationDataset(data=train_data, tokenizer=tokenizer, config=config)
    if config.valid_split is not None:
        valid_data = TextClassificationDataset(data=valid_data, tokenizer=tokenizer, config=config)
    if config.logging_steps == -1:
        if config.valid_split is not None:
            logging_steps = int(0.2 * len(valid_data) / config.batch_size)
        else:
            logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=2 * config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False)
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    if config.valid_split is not None:
        early_stop = EarlyStoppingCallback(early_stopping_patience=config.early_stopping_patience, early_stopping_threshold=config.early_stopping_threshold)
        callbacks_to_use = [early_stop]
    else:
        callbacks_to_use = []
    callbacks_to_use.extend([UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()])
    args = TrainingArguments(**training_args)
    trainer_args = dict(args=args, model=model, callbacks=callbacks_to_use, compute_metrics=utils._binary_classification_metrics if num_classes == 2 else utils._multi_class_classification_metrics)
    trainer = Trainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    logger.info('Finished training, saving model...')
    trainer.save_model(config.project_name)
    tokenizer.save_pretrained(config.project_name)
    model_card = utils.create_model_card(config, trainer, num_classes)
    with open(f'{config.project_name}/README.md', 'w') as f:
        f.write(model_card)
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            save_training_params(config)
            logger.info('Pushing model to hub...')
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)
if __name__ == '__main__':
    args = parse_args()
    training_config = json.load(open(args.training_config))
    config = TextClassificationParams(**training_config)
    train(config)

# File: autotrain-advanced-main/src/autotrain/trainers/text_classification/dataset.py
import torch

class TextClassificationDataset:

    def __init__(self, data, tokenizer, config):
        self.data = data
        self.tokenizer = tokenizer
        self.config = config
        self.text_column = self.config.text_column
        self.target_column = self.config.target_column

    def __len__(self):
        return len(self.data)

    def __getitem__(self, item):
        text = str(self.data[item][self.text_column])
        target = self.data[item][self.target_column]
        target = int(target)
        inputs = self.tokenizer(text, max_length=self.config.max_seq_length, padding='max_length', truncation=True)
        ids = inputs['input_ids']
        mask = inputs['attention_mask']
        if 'token_type_ids' in inputs:
            token_type_ids = inputs['token_type_ids']
        else:
            token_type_ids = None
        if token_type_ids is not None:
            return {'input_ids': torch.tensor(ids, dtype=torch.long), 'attention_mask': torch.tensor(mask, dtype=torch.long), 'token_type_ids': torch.tensor(token_type_ids, dtype=torch.long), 'labels': torch.tensor(target, dtype=torch.long)}
        return {'input_ids': torch.tensor(ids, dtype=torch.long), 'attention_mask': torch.tensor(mask, dtype=torch.long), 'labels': torch.tensor(target, dtype=torch.long)}

# File: autotrain-advanced-main/src/autotrain/trainers/text_classification/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class TextClassificationParams(AutoTrainParams):
    data_path: str = Field(None, title='Data path')
    model: str = Field('bert-base-uncased', title='Model name')
    lr: float = Field(5e-05, title='Learning rate')
    epochs: int = Field(3, title='Number of training epochs')
    max_seq_length: int = Field(128, title='Max sequence length')
    batch_size: int = Field(8, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(1, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    seed: int = Field(42, title='Seed')
    train_split: str = Field('train', title='Train split')
    valid_split: Optional[str] = Field(None, title='Validation split')
    text_column: str = Field('text', title='Text column')
    target_column: str = Field('target', title='Target column')
    logging_steps: int = Field(-1, title='Logging steps')
    project_name: str = Field('project-name', title='Output directory')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    save_total_limit: int = Field(1, title='Save total limit')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    log: str = Field('none', title='Logging using experiment tracking')
    early_stopping_patience: int = Field(5, title='Early stopping patience')
    early_stopping_threshold: float = Field(0.01, title='Early stopping threshold')

# File: autotrain-advanced-main/src/autotrain/trainers/text_classification/utils.py
import os
import numpy as np
import requests
from sklearn import metrics
BINARY_CLASSIFICATION_EVAL_METRICS = ('eval_loss', 'eval_accuracy', 'eval_f1', 'eval_auc', 'eval_precision', 'eval_recall')
MULTI_CLASS_CLASSIFICATION_EVAL_METRICS = ('eval_loss', 'eval_accuracy', 'eval_f1_macro', 'eval_f1_micro', 'eval_f1_weighted', 'eval_precision_macro', 'eval_precision_micro', 'eval_precision_weighted', 'eval_recall_macro', 'eval_recall_micro', 'eval_recall_weighted')
MODEL_CARD = '\n---\ntags:\n- autotrain\n- text-classification{base_model}\nwidget:\n- text: "I love AutoTrain"{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\n- Problem type: Text Classification\n\n## Validation Metrics\n{validation_metrics}\n'

def _binary_classification_metrics(pred):
    (raw_predictions, labels) = pred
    predictions = np.argmax(raw_predictions, axis=1)
    result = {'f1': metrics.f1_score(labels, predictions), 'precision': metrics.precision_score(labels, predictions), 'recall': metrics.recall_score(labels, predictions), 'auc': metrics.roc_auc_score(labels, raw_predictions[:, 1]), 'accuracy': metrics.accuracy_score(labels, predictions)}
    return result

def _multi_class_classification_metrics(pred):
    (raw_predictions, labels) = pred
    predictions = np.argmax(raw_predictions, axis=1)
    results = {'f1_macro': metrics.f1_score(labels, predictions, average='macro'), 'f1_micro': metrics.f1_score(labels, predictions, average='micro'), 'f1_weighted': metrics.f1_score(labels, predictions, average='weighted'), 'precision_macro': metrics.precision_score(labels, predictions, average='macro'), 'precision_micro': metrics.precision_score(labels, predictions, average='micro'), 'precision_weighted': metrics.precision_score(labels, predictions, average='weighted'), 'recall_macro': metrics.recall_score(labels, predictions, average='macro'), 'recall_micro': metrics.recall_score(labels, predictions, average='micro'), 'recall_weighted': metrics.recall_score(labels, predictions, average='weighted'), 'accuracy': metrics.accuracy_score(labels, predictions)}
    return results

def create_model_card(config, trainer, num_classes):
    if config.valid_split is not None:
        eval_scores = trainer.evaluate()
        valid_metrics = BINARY_CLASSIFICATION_EVAL_METRICS if num_classes == 2 else MULTI_CLASS_CLASSIFICATION_EVAL_METRICS
        eval_scores = [f"{k[len('eval_'):]}: {v}" for (k, v) in eval_scores.items() if k in valid_metrics]
        eval_scores = '\n\n'.join(eval_scores)
    else:
        eval_scores = 'No validation metrics available'
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, validation_metrics=eval_scores, base_model=base_model)
    return model_card

def pause_endpoint(params):
    endpoint_id = os.environ['ENDPOINT_ID']
    username = endpoint_id.split('/')[0]
    project_name = endpoint_id.split('/')[1]
    api_url = f'https://api.endpoints.huggingface.cloud/v2/endpoint/{username}/{project_name}/pause'
    headers = {'Authorization': f'Bearer {params.token}'}
    r = requests.post(api_url, headers=headers)
    return r.json()

# File: autotrain-advanced-main/src/autotrain/trainers/text_regression/__main__.py
import argparse
import json
from accelerate.state import PartialState
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from transformers import AutoConfig, AutoModelForSequenceClassification, AutoTokenizer, EarlyStoppingCallback, Trainer, TrainingArguments
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, monitor, pause_space, remove_autotrain_data, save_training_params
from autotrain.trainers.text_regression import utils
from autotrain.trainers.text_regression.dataset import TextRegressionDataset
from autotrain.trainers.text_regression.params import TextRegressionParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = TextRegressionParams(**config)
    train_data = None
    valid_data = None
    if config.train_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            train_data = load_from_disk(config.data_path)[config.train_split]
        elif ':' in config.train_split:
            (dataset_config_name, split) = config.train_split.split(':')
            train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
    model_config = AutoConfig.from_pretrained(config.model, num_labels=1, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token)
    model_config._num_labels = 1
    label2id = {'target': 0}
    model_config.label2id = label2id
    model_config.id2label = {v: k for (k, v) in label2id.items()}
    try:
        model = AutoModelForSequenceClassification.from_pretrained(config.model, config=model_config, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    except OSError:
        model = AutoModelForSequenceClassification.from_pretrained(config.model, config=model_config, from_tf=True, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    tokenizer = AutoTokenizer.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    train_data = TextRegressionDataset(data=train_data, tokenizer=tokenizer, config=config)
    if config.valid_split is not None:
        valid_data = TextRegressionDataset(data=valid_data, tokenizer=tokenizer, config=config)
    if config.logging_steps == -1:
        if config.valid_split is not None:
            logging_steps = int(0.2 * len(valid_data) / config.batch_size)
        else:
            logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=2 * config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False)
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    if config.valid_split is not None:
        early_stop = EarlyStoppingCallback(early_stopping_patience=config.early_stopping_patience, early_stopping_threshold=config.early_stopping_threshold)
        callbacks_to_use = [early_stop]
    else:
        callbacks_to_use = []
    callbacks_to_use.extend([UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()])
    args = TrainingArguments(**training_args)
    trainer_args = dict(args=args, model=model, callbacks=callbacks_to_use, compute_metrics=utils.single_column_regression_metrics)
    trainer = Trainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    logger.info('Finished training, saving model...')
    trainer.save_model(config.project_name)
    tokenizer.save_pretrained(config.project_name)
    model_card = utils.create_model_card(config, trainer)
    with open(f'{config.project_name}/README.md', 'w') as f:
        f.write(model_card)
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            save_training_params(config)
            logger.info('Pushing model to hub...')
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)
if __name__ == '__main__':
    args = parse_args()
    training_config = json.load(open(args.training_config))
    config = TextRegressionParams(**training_config)
    train(config)

# File: autotrain-advanced-main/src/autotrain/trainers/text_regression/dataset.py
import torch

class TextRegressionDataset:

    def __init__(self, data, tokenizer, config):
        self.data = data
        self.tokenizer = tokenizer
        self.config = config
        self.text_column = self.config.text_column
        self.target_column = self.config.target_column
        self.max_len = self.config.max_seq_length

    def __len__(self):
        return len(self.data)

    def __getitem__(self, item):
        text = str(self.data[item][self.text_column])
        target = float(self.data[item][self.target_column])
        inputs = self.tokenizer(text, max_length=self.max_len, padding='max_length', truncation=True)
        ids = inputs['input_ids']
        mask = inputs['attention_mask']
        if 'token_type_ids' in inputs:
            token_type_ids = inputs['token_type_ids']
        else:
            token_type_ids = None
        if token_type_ids is not None:
            return {'input_ids': torch.tensor(ids, dtype=torch.long), 'attention_mask': torch.tensor(mask, dtype=torch.long), 'token_type_ids': torch.tensor(token_type_ids, dtype=torch.long), 'labels': torch.tensor(target, dtype=torch.float)}
        return {'input_ids': torch.tensor(ids, dtype=torch.long), 'attention_mask': torch.tensor(mask, dtype=torch.long), 'labels': torch.tensor(target, dtype=torch.float)}

# File: autotrain-advanced-main/src/autotrain/trainers/text_regression/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class TextRegressionParams(AutoTrainParams):
    data_path: str = Field(None, title='Data path')
    model: str = Field('bert-base-uncased', title='Model name')
    lr: float = Field(5e-05, title='Learning rate')
    epochs: int = Field(3, title='Number of training epochs')
    max_seq_length: int = Field(128, title='Max sequence length')
    batch_size: int = Field(8, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(1, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    seed: int = Field(42, title='Seed')
    train_split: str = Field('train', title='Train split')
    valid_split: Optional[str] = Field(None, title='Validation split')
    text_column: str = Field('text', title='Text column')
    target_column: str = Field('target', title='Target column(s)')
    logging_steps: int = Field(-1, title='Logging steps')
    project_name: str = Field('project-name', title='Output directory')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    save_total_limit: int = Field(1, title='Save total limit')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    log: str = Field('none', title='Logging using experiment tracking')
    early_stopping_patience: int = Field(5, title='Early stopping patience')
    early_stopping_threshold: float = Field(0.01, title='Early stopping threshold')

# File: autotrain-advanced-main/src/autotrain/trainers/text_regression/utils.py
import os
import numpy as np
from sklearn import metrics
SINGLE_COLUMN_REGRESSION_EVAL_METRICS = ('eval_loss', 'eval_mse', 'eval_mae', 'eval_r2', 'eval_rmse', 'eval_explained_variance')
MODEL_CARD = '\n---\ntags:\n- autotrain\n- text-regression{base_model}\nwidget:\n- text: "I love AutoTrain"{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\n- Problem type: Text Regression\n\n## Validation Metrics\n{validation_metrics}\n'

def single_column_regression_metrics(pred):
    (raw_predictions, labels) = pred

    def safe_compute(metric_func, default=-999):
        try:
            return metric_func(labels, raw_predictions)
        except Exception:
            return default
    pred_dict = {'mse': safe_compute(lambda labels, predictions: metrics.mean_squared_error(labels, predictions)), 'mae': safe_compute(lambda labels, predictions: metrics.mean_absolute_error(labels, predictions)), 'r2': safe_compute(lambda labels, predictions: metrics.r2_score(labels, predictions)), 'rmse': safe_compute(lambda labels, predictions: np.sqrt(metrics.mean_squared_error(labels, predictions))), 'explained_variance': safe_compute(lambda labels, predictions: metrics.explained_variance_score(labels, predictions))}
    for (key, value) in pred_dict.items():
        pred_dict[key] = float(value)
    return pred_dict

def create_model_card(config, trainer):
    if config.valid_split is not None:
        eval_scores = trainer.evaluate()
        eval_scores = [f"{k[len('eval_'):]}: {v}" for (k, v) in eval_scores.items() if k in SINGLE_COLUMN_REGRESSION_EVAL_METRICS]
        eval_scores = '\n\n'.join(eval_scores)
    else:
        eval_scores = 'No validation metrics available'
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, validation_metrics=eval_scores, base_model=base_model)
    return model_card

# File: autotrain-advanced-main/src/autotrain/trainers/token_classification/__main__.py
import argparse
import json
from functools import partial
from accelerate.state import PartialState
from datasets import load_dataset, load_from_disk
from huggingface_hub import HfApi
from transformers import AutoConfig, AutoModelForTokenClassification, AutoTokenizer, EarlyStoppingCallback, Trainer, TrainingArguments
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, monitor, pause_space, remove_autotrain_data, save_training_params
from autotrain.trainers.token_classification import utils
from autotrain.trainers.token_classification.dataset import TokenClassificationDataset
from autotrain.trainers.token_classification.params import TokenClassificationParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = TokenClassificationParams(**config)
    train_data = None
    valid_data = None
    if config.train_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            train_data = load_from_disk(config.data_path)[config.train_split]
        elif ':' in config.train_split:
            (dataset_config_name, split) = config.train_split.split(':')
            train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            logger.info('loading dataset from disk')
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
    label_list = train_data.features[config.tags_column].feature.names
    num_classes = len(label_list)
    model_config = AutoConfig.from_pretrained(config.model, num_labels=num_classes)
    model_config._num_labels = num_classes
    model_config.label2id = {l: i for (i, l) in enumerate(label_list)}
    model_config.id2label = dict(enumerate(label_list))
    try:
        model = AutoModelForTokenClassification.from_pretrained(config.model, config=model_config, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    except OSError:
        model = AutoModelForTokenClassification.from_pretrained(config.model, config=model_config, from_tf=True, trust_remote_code=ALLOW_REMOTE_CODE, token=config.token, ignore_mismatched_sizes=True)
    if model_config.model_type in {'bloom', 'gpt2', 'roberta'}:
        tokenizer = AutoTokenizer.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, add_prefix_space=True)
    else:
        tokenizer = AutoTokenizer.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    train_data = TokenClassificationDataset(data=train_data, tokenizer=tokenizer, config=config)
    if config.valid_split is not None:
        valid_data = TokenClassificationDataset(data=valid_data, tokenizer=tokenizer, config=config)
    if config.logging_steps == -1:
        if config.valid_split is not None:
            logging_steps = int(0.2 * len(valid_data) / config.batch_size)
        else:
            logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=2 * config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False)
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    if config.valid_split is not None:
        early_stop = EarlyStoppingCallback(early_stopping_patience=config.early_stopping_patience, early_stopping_threshold=config.early_stopping_threshold)
        callbacks_to_use = [early_stop]
    else:
        callbacks_to_use = []
    callbacks_to_use.extend([UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()])
    args = TrainingArguments(**training_args)
    trainer_args = dict(args=args, model=model, callbacks=callbacks_to_use, compute_metrics=partial(utils.token_classification_metrics, label_list=label_list))
    trainer = Trainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    logger.info('Finished training, saving model...')
    trainer.save_model(config.project_name)
    tokenizer.save_pretrained(config.project_name)
    model_card = utils.create_model_card(config, trainer)
    with open(f'{config.project_name}/README.md', 'w', encoding='utf-8') as f:
        f.write(model_card)
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            save_training_params(config)
            logger.info('Pushing model to hub...')
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)
if __name__ == '__main__':
    args = parse_args()
    training_config = json.load(open(args.training_config))
    config = TokenClassificationParams(**training_config)
    train(config)

# File: autotrain-advanced-main/src/autotrain/trainers/token_classification/dataset.py
class TokenClassificationDataset:

    def __init__(self, data, tokenizer, config):
        self.data = data
        self.tokenizer = tokenizer
        self.config = config

    def __len__(self):
        return len(self.data)

    def __getitem__(self, item):
        text = self.data[item][self.config.tokens_column]
        tags = self.data[item][self.config.tags_column]
        label_list = self.data.features[self.config.tags_column].feature.names
        label_to_id = {i: i for i in range(len(label_list))}
        tokenized_text = self.tokenizer(text, max_length=self.config.max_seq_length, padding='max_length', truncation=True, is_split_into_words=True)
        word_ids = tokenized_text.word_ids(batch_index=0)
        previous_word_idx = None
        label_ids = []
        for word_idx in word_ids:
            if word_idx is None:
                label_ids.append(-100)
            elif word_idx != previous_word_idx:
                label_ids.append(label_to_id[tags[word_idx]])
            else:
                label_ids.append(label_to_id[tags[word_idx]])
            previous_word_idx = word_idx
        tokenized_text['labels'] = label_ids
        return tokenized_text

# File: autotrain-advanced-main/src/autotrain/trainers/token_classification/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class TokenClassificationParams(AutoTrainParams):
    data_path: str = Field(None, title='Data path')
    model: str = Field('bert-base-uncased', title='Model name')
    lr: float = Field(5e-05, title='Learning rate')
    epochs: int = Field(3, title='Number of training epochs')
    max_seq_length: int = Field(128, title='Max sequence length')
    batch_size: int = Field(8, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(1, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    seed: int = Field(42, title='Seed')
    train_split: str = Field('train', title='Train split')
    valid_split: Optional[str] = Field(None, title='Validation split')
    tokens_column: str = Field('tokens', title='Tokens column')
    tags_column: str = Field('tags', title='Tags column')
    logging_steps: int = Field(-1, title='Logging steps')
    project_name: str = Field('project-name', title='Output directory')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    save_total_limit: int = Field(1, title='Save total limit')
    token: Optional[str] = Field(None, title='Hub Token')
    push_to_hub: bool = Field(False, title='Push to hub')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    log: str = Field('none', title='Logging using experiment tracking')
    early_stopping_patience: int = Field(5, title='Early stopping patience')
    early_stopping_threshold: float = Field(0.01, title='Early stopping threshold')

# File: autotrain-advanced-main/src/autotrain/trainers/token_classification/utils.py
import os
import numpy as np
from seqeval import metrics
MODEL_CARD = '\n---\ntags:\n- autotrain\n- token-classification{base_model}\nwidget:\n- text: "I love AutoTrain"{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\n- Problem type: Token Classification\n\n## Validation Metrics\n{validation_metrics}\n'

def token_classification_metrics(pred, label_list):
    (predictions, labels) = pred
    predictions = np.argmax(predictions, axis=2)
    true_predictions = [[label_list[predi] for (predi, lbl) in zip(prediction, label) if lbl != -100] for (prediction, label) in zip(predictions, labels)]
    true_labels = [[label_list[lbl] for (predi, lbl) in zip(prediction, label) if lbl != -100] for (prediction, label) in zip(predictions, labels)]
    results = {'precision': metrics.precision_score(true_labels, true_predictions), 'recall': metrics.recall_score(true_labels, true_predictions), 'f1': metrics.f1_score(true_labels, true_predictions), 'accuracy': metrics.accuracy_score(true_labels, true_predictions)}
    return results

def create_model_card(config, trainer):
    if config.valid_split is not None:
        eval_scores = trainer.evaluate()
        valid_metrics = ['eval_loss', 'eval_precision', 'eval_recall', 'eval_f1', 'eval_accuracy']
        eval_scores = [f"{k[len('eval_'):]}: {v}" for (k, v) in eval_scores.items() if k in valid_metrics]
        eval_scores = '\n\n'.join(eval_scores)
    else:
        eval_scores = 'No validation metrics available'
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, validation_metrics=eval_scores, base_model=base_model)
    return model_card

# File: autotrain-advanced-main/src/autotrain/trainers/vlm/__main__.py
import argparse
import json
from autotrain.trainers.common import monitor
from autotrain.trainers.vlm import utils
from autotrain.trainers.vlm.params import VLMTrainingParams

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_config', type=str, required=True)
    return parser.parse_args()

@monitor
def train(config):
    if isinstance(config, dict):
        config = VLMTrainingParams(**config)
    if not utils.check_model_support(config):
        raise ValueError(f'model `{config.model}` not supported')
    if config.trainer in ('vqa', 'captioning'):
        from autotrain.trainers.vlm.train_vlm_generic import train as train_generic
        train_generic(config)
    else:
        raise ValueError(f'trainer `{config.trainer}` not supported')
if __name__ == '__main__':
    _args = parse_args()
    training_config = json.load(open(_args.training_config))
    _config = VLMTrainingParams(**training_config)
    train(_config)

# File: autotrain-advanced-main/src/autotrain/trainers/vlm/params.py
from typing import Optional
from pydantic import Field
from autotrain.trainers.common import AutoTrainParams

class VLMTrainingParams(AutoTrainParams):
    model: str = Field('google/paligemma-3b-pt-224', title='Model name')
    project_name: str = Field('project-name', title='Output directory')
    data_path: str = Field('data', title='Data path')
    train_split: str = Field('train', title='Train data config')
    valid_split: Optional[str] = Field(None, title='Validation data config')
    trainer: str = Field('vqa', title='Trainer type')
    log: str = Field('none', title='Logging using experiment tracking')
    disable_gradient_checkpointing: bool = Field(False, title='Gradient checkpointing')
    logging_steps: int = Field(-1, title='Logging steps')
    eval_strategy: str = Field('epoch', title='Evaluation strategy')
    save_total_limit: int = Field(1, title='Save total limit')
    auto_find_batch_size: bool = Field(False, title='Auto find batch size')
    mixed_precision: Optional[str] = Field(None, title='fp16, bf16, or None')
    lr: float = Field(3e-05, title='Learning rate')
    epochs: int = Field(1, title='Number of training epochs')
    batch_size: int = Field(2, title='Training batch size')
    warmup_ratio: float = Field(0.1, title='Warmup proportion')
    gradient_accumulation: int = Field(4, title='Gradient accumulation steps')
    optimizer: str = Field('adamw_torch', title='Optimizer')
    scheduler: str = Field('linear', title='Scheduler')
    weight_decay: float = Field(0.0, title='Weight decay')
    max_grad_norm: float = Field(1.0, title='Max gradient norm')
    seed: int = Field(42, title='Seed')
    quantization: Optional[str] = Field('int4', title='int4, int8, or None')
    target_modules: Optional[str] = Field('all-linear', title='Target modules')
    merge_adapter: bool = Field(False, title='Merge adapter')
    peft: bool = Field(False, title='Use PEFT')
    lora_r: int = Field(16, title='Lora r')
    lora_alpha: int = Field(32, title='Lora alpha')
    lora_dropout: float = Field(0.05, title='Lora dropout')
    image_column: Optional[str] = Field('image', title='Image column')
    text_column: str = Field('text', title='Text (answer) column')
    prompt_text_column: Optional[str] = Field('prompt', title='Prompt (prefix) column')
    push_to_hub: bool = Field(False, title='Push to hub')
    username: Optional[str] = Field(None, title='Hugging Face Username')
    token: Optional[str] = Field(None, title='Huggingface token')

# File: autotrain-advanced-main/src/autotrain/trainers/vlm/train_vlm_generic.py
from functools import partial
from datasets import load_dataset, load_from_disk
from transformers import AutoProcessor, Trainer, TrainingArguments
from transformers.trainer_callback import PrinterCallback
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE
from autotrain.trainers.vlm import utils

def collate_fn(examples, config, processor):
    prompts = ['answer ' + example[config.prompt_text_column] for example in examples]
    labels = [example[config.text_column] for example in examples]
    images = [example[config.image_column].convert('RGB') for example in examples]
    tokens = processor(text=prompts, images=images, suffix=labels, return_tensors='pt', padding='longest', tokenize_newline_separately=False)
    return tokens

def train(config):
    valid_data = None
    if config.data_path == f'{config.project_name}/autotrain-data':
        train_data = load_from_disk(config.data_path)[config.train_split]
    elif ':' in config.train_split:
        (dataset_config_name, split) = config.train_split.split(':')
        train_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
    else:
        train_data = load_dataset(config.data_path, split=config.train_split, token=config.token)
    if config.valid_split is not None:
        if config.data_path == f'{config.project_name}/autotrain-data':
            valid_data = load_from_disk(config.data_path)[config.valid_split]
        elif ':' in config.valid_split:
            (dataset_config_name, split) = config.valid_split.split(':')
            valid_data = load_dataset(config.data_path, name=dataset_config_name, split=split, token=config.token)
        else:
            valid_data = load_dataset(config.data_path, split=config.valid_split, token=config.token)
    logger.info(f'Train data: {train_data}')
    logger.info(f'Valid data: {valid_data}')
    if config.trainer == 'captioning':
        config.prompt_text_column = 'caption'
    processor = AutoProcessor.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    logging_steps = utils.configure_logging_steps(config, train_data, valid_data)
    training_args = utils.configure_training_args(config, logging_steps)
    args = TrainingArguments(**training_args)
    model = utils.get_model(config)
    logger.info('creating trainer')
    callbacks = utils.get_callbacks(config)
    trainer_args = dict(args=args, model=model, callbacks=callbacks)
    col_fn = partial(collate_fn, config=config, processor=processor)
    trainer = Trainer(**trainer_args, train_dataset=train_data, eval_dataset=valid_data if valid_data is not None else None, data_collator=col_fn)
    trainer.remove_callback(PrinterCallback)
    trainer.train()
    utils.post_training_steps(config, trainer)

# File: autotrain-advanced-main/src/autotrain/trainers/vlm/utils.py
import os
import torch
from accelerate import PartialState
from huggingface_hub import HfApi
from peft import LoraConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training
from transformers import AutoConfig, BitsAndBytesConfig, PaliGemmaForConditionalGeneration
from autotrain import logger
from autotrain.trainers.common import ALLOW_REMOTE_CODE, LossLoggingCallback, TrainStartCallback, UploadLogs, pause_space, remove_autotrain_data, save_training_params
TARGET_MODULES = {}
SUPPORTED_MODELS = ['PaliGemmaForConditionalGeneration']
MODEL_CARD = '\n---\ntags:\n- autotrain\n- text-generation-inference\n- image-text-to-text\n- text-generation{peft}\nlibrary_name: transformers{base_model}\nlicense: other{dataset_tag}\n---\n\n# Model Trained Using AutoTrain\n\nThis model was trained using AutoTrain. For more information, please visit [AutoTrain](https://hf.co/docs/autotrain).\n\n# Usage\n\n```python\n# you will need to adjust code if you didnt use peft\n\nfrom PIL import Image\nfrom transformers import PaliGemmaForConditionalGeneration, PaliGemmaProcessor\nimport torch\nimport requests\nfrom peft import PeftModel\n\nbase_model_id = BASE_MODEL_ID\npeft_model_id = THIS_MODEL_ID\nmax_new_tokens = 100\ntext = "Whats on the flower?"\nimg_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/bee.JPG?download=true"\nimage = Image.open(requests.get(img_url, stream=True).raw)\n\ndevice = torch.device("cuda" if torch.cuda.is_available() else "cpu")\nbase_model = PaliGemmaForConditionalGeneration.from_pretrained(base_model_id)\nprocessor = PaliGemmaProcessor.from_pretrained(base_model_id)\n\nmodel = PeftModel.from_pretrained(base_model, peft_model_id)\nmodel.merge_and_unload()\n\nmodel = model.eval().to(device)\n\ninputs = processor(text=text, images=image, return_tensors="pt").to(device)\nwith torch.inference_mode():\n    generated_ids = model.generate(\n        **inputs,\n        max_new_tokens=max_new_tokens,\n        do_sample=False,\n    )\nresult = processor.batch_decode(generated_ids, skip_special_tokens=True)\nprint(result)\n```\n'

def get_target_modules(config):
    if config.target_modules is None:
        return TARGET_MODULES.get(config.model)
    if config.target_modules.strip() == '':
        return TARGET_MODULES.get(config.model)
    if config.target_modules.strip().lower() == 'all-linear':
        return 'all-linear'
    return config.target_modules.split(',')

def create_model_card(config):
    if config.peft:
        peft = '\n- peft'
    else:
        peft = ''
    if config.data_path == f'{config.project_name}/autotrain-data' or os.path.isdir(config.data_path):
        dataset_tag = ''
    else:
        dataset_tag = f'\ndatasets:\n- {config.data_path}'
    if os.path.isdir(config.model):
        base_model = ''
    else:
        base_model = f'\nbase_model: {config.model}'
    model_card = MODEL_CARD.format(dataset_tag=dataset_tag, peft=peft, base_model=base_model)
    return model_card.strip()

def check_model_support(config):
    api = HfApi(token=config.token)
    model_info = api.model_info(config.model)
    architectures = model_info.config.get('architectures', [])
    for arch in architectures:
        if arch in SUPPORTED_MODELS:
            return True
    return False

def configure_logging_steps(config, train_data, valid_data):
    logger.info('configuring logging steps')
    if config.logging_steps == -1:
        if config.valid_split is not None:
            logging_steps = int(0.2 * len(valid_data) / config.batch_size)
        else:
            logging_steps = int(0.2 * len(train_data) / config.batch_size)
        if logging_steps == 0:
            logging_steps = 1
        if logging_steps > 25:
            logging_steps = 25
        config.logging_steps = logging_steps
    else:
        logging_steps = config.logging_steps
    logger.info(f'Logging steps: {logging_steps}')
    return logging_steps

def configure_training_args(config, logging_steps):
    logger.info('configuring training args')
    training_args = dict(output_dir=config.project_name, per_device_train_batch_size=config.batch_size, per_device_eval_batch_size=config.batch_size, learning_rate=config.lr, num_train_epochs=config.epochs, eval_strategy=config.eval_strategy if config.valid_split is not None else 'no', logging_steps=logging_steps, save_total_limit=config.save_total_limit, save_strategy=config.eval_strategy if config.valid_split is not None else 'no', gradient_accumulation_steps=config.gradient_accumulation, report_to=config.log, auto_find_batch_size=config.auto_find_batch_size, lr_scheduler_type=config.scheduler, optim=config.optimizer, warmup_ratio=config.warmup_ratio, weight_decay=config.weight_decay, max_grad_norm=config.max_grad_norm, push_to_hub=False, load_best_model_at_end=True if config.valid_split is not None else False, ddp_find_unused_parameters=False, gradient_checkpointing=not config.disable_gradient_checkpointing, remove_unused_columns=False)
    if not config.disable_gradient_checkpointing:
        if config.peft and config.quantization in ('int4', 'int8'):
            training_args['gradient_checkpointing_kwargs'] = {'use_reentrant': True}
        else:
            training_args['gradient_checkpointing_kwargs'] = {'use_reentrant': False}
    if config.mixed_precision == 'fp16':
        training_args['fp16'] = True
    if config.mixed_precision == 'bf16':
        training_args['bf16'] = True
    return training_args

def get_callbacks(config):
    callbacks = [UploadLogs(config=config), LossLoggingCallback(), TrainStartCallback()]
    return callbacks

def get_model(config):
    logger.info('loading model config...')
    model_config = AutoConfig.from_pretrained(config.model, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE, use_cache=config.disable_gradient_checkpointing)
    logger.info('loading model...')
    if config.peft:
        if config.quantization == 'int4':
            bnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type='nf4', bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=False)
        elif config.quantization == 'int8':
            bnb_config = BitsAndBytesConfig(load_in_8bit=True)
        else:
            bnb_config = None
        model = PaliGemmaForConditionalGeneration.from_pretrained(config.model, config=model_config, token=config.token, quantization_config=bnb_config, trust_remote_code=ALLOW_REMOTE_CODE)
    else:
        model = PaliGemmaForConditionalGeneration.from_pretrained(config.model, config=model_config, token=config.token, trust_remote_code=ALLOW_REMOTE_CODE)
    logger.info(f'model dtype: {model.dtype}')
    if config.peft:
        logger.info('preparing peft model...')
        if config.quantization is not None:
            gradient_checkpointing_kwargs = {}
            if not config.disable_gradient_checkpointing:
                if config.quantization in ('int4', 'int8'):
                    gradient_checkpointing_kwargs = {'use_reentrant': True}
                else:
                    gradient_checkpointing_kwargs = {'use_reentrant': False}
            model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=not config.disable_gradient_checkpointing, gradient_checkpointing_kwargs=gradient_checkpointing_kwargs)
        else:
            model.enable_input_require_grads()
        peft_config = LoraConfig(r=config.lora_r, lora_alpha=config.lora_alpha, lora_dropout=config.lora_dropout, bias='none', task_type='CAUSAL_LM', target_modules=get_target_modules(config))
        model = get_peft_model(model, peft_config)
    for param in model.vision_tower.parameters():
        param.requires_grad = False
    for param in model.multi_modal_projector.parameters():
        param.requires_grad = False
    return model

def merge_adapter(base_model_path, target_model_path, adapter_path):
    logger.info('Loading adapter...')
    model = PaliGemmaForConditionalGeneration.from_pretrained(base_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True, trust_remote_code=ALLOW_REMOTE_CODE)
    model = PeftModel.from_pretrained(model, adapter_path)
    model = model.merge_and_unload()
    logger.info('Saving target model...')
    model.save_pretrained(target_model_path)

def post_training_steps(config, trainer):
    logger.info('Finished training, saving model...')
    trainer.model.config.use_cache = True
    trainer.save_model(config.project_name)
    model_card = create_model_card(config)
    with open(f'{config.project_name}/README.md', 'w', encoding='utf-8') as f:
        f.write(model_card)
    if config.peft and config.merge_adapter:
        logger.info('Merging adapter weights...')
        try:
            del trainer
            torch.cuda.empty_cache()
            merge_adapter(base_model_path=config.model, target_model_path=config.project_name, adapter_path=config.project_name)
            for file in os.listdir(config.project_name):
                if file.startswith('adapter_'):
                    os.remove(f'{config.project_name}/{file}')
        except Exception as e:
            logger.warning(f'Failed to merge adapter weights: {e}')
            logger.warning('Skipping adapter merge. Only adapter weights will be saved.')
    if config.push_to_hub:
        if PartialState().process_index == 0:
            remove_autotrain_data(config)
            logger.info('Pushing model to hub...')
            save_training_params(config)
            api = HfApi(token=config.token)
            api.create_repo(repo_id=f'{config.username}/{config.project_name}', repo_type='model', private=True, exist_ok=True)
            api.upload_folder(folder_path=config.project_name, repo_id=f'{config.username}/{config.project_name}', repo_type='model')
    if PartialState().process_index == 0:
        pause_space(config)

# File: autotrain-advanced-main/src/autotrain/utils.py
import json
import os
import subprocess
from autotrain.commands import launch_command
from autotrain.trainers.clm.params import LLMTrainingParams
from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams
from autotrain.trainers.extractive_question_answering.params import ExtractiveQuestionAnsweringParams
from autotrain.trainers.generic.params import GenericParams
from autotrain.trainers.image_classification.params import ImageClassificationParams
from autotrain.trainers.image_regression.params import ImageRegressionParams
from autotrain.trainers.object_detection.params import ObjectDetectionParams
from autotrain.trainers.sent_transformers.params import SentenceTransformersParams
from autotrain.trainers.seq2seq.params import Seq2SeqParams
from autotrain.trainers.tabular.params import TabularParams
from autotrain.trainers.text_classification.params import TextClassificationParams
from autotrain.trainers.text_regression.params import TextRegressionParams
from autotrain.trainers.token_classification.params import TokenClassificationParams
from autotrain.trainers.vlm.params import VLMTrainingParams
ALLOW_REMOTE_CODE = os.environ.get('ALLOW_REMOTE_CODE', 'true').lower() == 'true'

def run_training(params, task_id, local=False, wait=False):
    params = json.loads(params)
    if isinstance(params, str):
        params = json.loads(params)
    if task_id == 9:
        params = LLMTrainingParams(**params)
    elif task_id == 28:
        params = Seq2SeqParams(**params)
    elif task_id in (1, 2):
        params = TextClassificationParams(**params)
    elif task_id in (13, 14, 15, 16, 26):
        params = TabularParams(**params)
    elif task_id == 27:
        params = GenericParams(**params)
    elif task_id == 25:
        params = DreamBoothTrainingParams(**params)
    elif task_id == 18:
        params = ImageClassificationParams(**params)
    elif task_id == 4:
        params = TokenClassificationParams(**params)
    elif task_id == 10:
        params = TextRegressionParams(**params)
    elif task_id == 29:
        params = ObjectDetectionParams(**params)
    elif task_id == 30:
        params = SentenceTransformersParams(**params)
    elif task_id == 24:
        params = ImageRegressionParams(**params)
    elif task_id == 31:
        params = VLMTrainingParams(**params)
    elif task_id == 5:
        params = ExtractiveQuestionAnsweringParams(**params)
    else:
        raise NotImplementedError
    params.save(output_dir=params.project_name)
    cmd = launch_command(params=params)
    cmd = [str(c) for c in cmd]
    env = os.environ.copy()
    process = subprocess.Popen(cmd, env=env)
    if wait:
        process.wait()
    return process.pid