




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

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

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


UpperCamelCase__         =      logging.getLogger(__name__)

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






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






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







def      _a				(						SCREAMING_SNAKE_CASE_							:    List[str]				,				SCREAMING_SNAKE_CASE_							:    str				,				SCREAMING_SNAKE_CASE_							:    Any				,				SCREAMING_SNAKE_CASE_							:    Any				,				SCREAMING_SNAKE_CASE_							:    List[str]				,				SCREAMING_SNAKE_CASE_							:    Union[str, Any]					):
					__lowerCAmelCase           =	datasets.concatenate_datasets([infer_input, infer_output]				,				axis=1					)

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

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

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

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







def      _a				(						SCREAMING_SNAKE_CASE_							:    Union[str, Any]				,				SCREAMING_SNAKE_CASE_							:    Any				,				SCREAMING_SNAKE_CASE_							:    Optional[int]				,				SCREAMING_SNAKE_CASE_							:    Union[str, Any]				,				**SCREAMING_SNAKE_CASE_							:    Union[str, Any]					):
					__lowerCAmelCase           =	Accelerator()
					# Make one log on every process with the configuration for debugging.
					logging.basicConfig(
					    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"				,				datefmt="%m/%d/%Y %H:%M:%S"				,				level=logging.INFO				,				)
					logger.info(accelerator.state					)

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

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

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

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

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

    # Sanity checks
					__lowerCAmelCase           =	{}
					__lowerCAmelCase           =	None

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

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

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

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

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

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

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

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

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

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

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

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

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

										__lowerCAmelCase           =	iteration
										__lowerCAmelCase           =	data_dir_format(iteration + 1					)

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

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

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

										__lowerCAmelCase           =	os.path.join(a__				,				F"""train_pseudo.{args.data_file_extension}"""					)

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

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

																				if early_stopping_patience_counter >= args.early_stopping_patience:
																									__lowerCAmelCase           =	True

										progress_bar.update(1					)

										if should_training_stop:
															break

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










UpperCamelCase__         =      """0.18.2"""

from .configuration_utils import ConfigMixin
from .utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    logging,
)


try:
					if not is_onnx_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_onnx_objects import *  # noqa F403
else:
					from .pipelines import OnnxRuntimeModel

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_pt_objects import *  # noqa F403
else:
					from .models import (
					    AutoencoderKL,
					    ControlNetModel,
					    ModelMixin,
					    PriorTransformer,
					    TaFilmDecoder,
					    TransformeraDModel,
					    UNetaDModel,
					    UNetaDConditionModel,
					    UNetaDModel,
					    UNetaDConditionModel,
					    VQModel,
					)
					from .optimization import (
					    get_constant_schedule,
					    get_constant_schedule_with_warmup,
					    get_cosine_schedule_with_warmup,
					    get_cosine_with_hard_restarts_schedule_with_warmup,
					    get_linear_schedule_with_warmup,
					    get_polynomial_decay_schedule_with_warmup,
					    get_scheduler,
					)
					from .pipelines import (
					    AudioPipelineOutput,
					    ConsistencyModelPipeline,
					    DanceDiffusionPipeline,
					    DDIMPipeline,
					    DDPMPipeline,
					    DiffusionPipeline,
					    DiTPipeline,
					    ImagePipelineOutput,
					    KarrasVePipeline,
					    LDMPipeline,
					    LDMSuperResolutionPipeline,
					    PNDMPipeline,
					    RePaintPipeline,
					    ScoreSdeVePipeline,
					)
					from .schedulers import (
					    CMStochasticIterativeScheduler,
					    DDIMInverseScheduler,
					    DDIMParallelScheduler,
					    DDIMScheduler,
					    DDPMParallelScheduler,
					    DDPMScheduler,
					    DEISMultistepScheduler,
					    DPMSolverMultistepInverseScheduler,
					    DPMSolverMultistepScheduler,
					    DPMSolverSinglestepScheduler,
					    EulerAncestralDiscreteScheduler,
					    EulerDiscreteScheduler,
					    HeunDiscreteScheduler,
					    IPNDMScheduler,
					    KarrasVeScheduler,
					    KDPMaAncestralDiscreteScheduler,
					    KDPMaDiscreteScheduler,
					    PNDMScheduler,
					    RePaintScheduler,
					    SchedulerMixin,
					    ScoreSdeVeScheduler,
					    UnCLIPScheduler,
					    UniPCMultistepScheduler,
					    VQDiffusionScheduler,
					)
					from .training_utils import EMAModel

try:
					if not (is_torch_available() and is_scipy_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
					from .schedulers import LMSDiscreteScheduler

try:
					if not (is_torch_available() and is_torchsde_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
					from .schedulers import DPMSolverSDEScheduler

try:
					if not (is_torch_available() and is_transformers_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
					from .pipelines import (
					    AltDiffusionImgaImgPipeline,
					    AltDiffusionPipeline,
					    AudioLDMPipeline,
					    CycleDiffusionPipeline,
					    IFImgaImgPipeline,
					    IFImgaImgSuperResolutionPipeline,
					    IFInpaintingPipeline,
					    IFInpaintingSuperResolutionPipeline,
					    IFPipeline,
					    IFSuperResolutionPipeline,
					    ImageTextPipelineOutput,
					    KandinskyImgaImgPipeline,
					    KandinskyInpaintPipeline,
					    KandinskyPipeline,
					    KandinskyPriorPipeline,
					    KandinskyVaaControlnetImgaImgPipeline,
					    KandinskyVaaControlnetPipeline,
					    KandinskyVaaImgaImgPipeline,
					    KandinskyVaaInpaintPipeline,
					    KandinskyVaaPipeline,
					    KandinskyVaaPriorEmbaEmbPipeline,
					    KandinskyVaaPriorPipeline,
					    LDMTextToImagePipeline,
					    PaintByExamplePipeline,
					    SemanticStableDiffusionPipeline,
					    ShapEImgaImgPipeline,
					    ShapEPipeline,
					    StableDiffusionAttendAndExcitePipeline,
					    StableDiffusionControlNetImgaImgPipeline,
					    StableDiffusionControlNetInpaintPipeline,
					    StableDiffusionControlNetPipeline,
					    StableDiffusionDepthaImgPipeline,
					    StableDiffusionDiffEditPipeline,
					    StableDiffusionImageVariationPipeline,
					    StableDiffusionImgaImgPipeline,
					    StableDiffusionInpaintPipeline,
					    StableDiffusionInpaintPipelineLegacy,
					    StableDiffusionInstructPixaPixPipeline,
					    StableDiffusionLatentUpscalePipeline,
					    StableDiffusionLDMaDPipeline,
					    StableDiffusionModelEditingPipeline,
					    StableDiffusionPanoramaPipeline,
					    StableDiffusionParadigmsPipeline,
					    StableDiffusionPipeline,
					    StableDiffusionPipelineSafe,
					    StableDiffusionPixaPixZeroPipeline,
					    StableDiffusionSAGPipeline,
					    StableDiffusionUpscalePipeline,
					    StableUnCLIPImgaImgPipeline,
					    StableUnCLIPPipeline,
					    TextToVideoSDPipeline,
					    TextToVideoZeroPipeline,
					    UnCLIPImageVariationPipeline,
					    UnCLIPPipeline,
					    UniDiffuserModel,
					    UniDiffuserPipeline,
					    UniDiffuserTextDecoder,
					    VersatileDiffusionDualGuidedPipeline,
					    VersatileDiffusionImageVariationPipeline,
					    VersatileDiffusionPipeline,
					    VersatileDiffusionTextToImagePipeline,
					    VideoToVideoSDPipeline,
					    VQDiffusionPipeline,
					)

try:
					if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
					from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
					if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
					from .pipelines import StableDiffusionKDiffusionPipeline

try:
					if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
					from .pipelines import (
					    OnnxStableDiffusionImgaImgPipeline,
					    OnnxStableDiffusionInpaintPipeline,
					    OnnxStableDiffusionInpaintPipelineLegacy,
					    OnnxStableDiffusionPipeline,
					    OnnxStableDiffusionUpscalePipeline,
					    StableDiffusionOnnxPipeline,
					)

try:
					if not (is_torch_available() and is_librosa_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
					from .pipelines import AudioDiffusionPipeline, Mel

try:
					if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
					from .pipelines import SpectrogramDiffusionPipeline

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_flax_objects import *  # noqa F403
else:
					from .models.controlnet_flax import FlaxControlNetModel
					from .models.modeling_flax_utils import FlaxModelMixin
					from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel
					from .models.vae_flax import FlaxAutoencoderKL
					from .pipelines import FlaxDiffusionPipeline
					from .schedulers import (
					    FlaxDDIMScheduler,
					    FlaxDDPMScheduler,
					    FlaxDPMSolverMultistepScheduler,
					    FlaxKarrasVeScheduler,
					    FlaxLMSDiscreteScheduler,
					    FlaxPNDMScheduler,
					    FlaxSchedulerMixin,
					    FlaxScoreSdeVeScheduler,
					)


try:
					if not (is_flax_available() and is_transformers_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
					from .pipelines import (
					    FlaxStableDiffusionControlNetPipeline,
					    FlaxStableDiffusionImgaImgPipeline,
					    FlaxStableDiffusionInpaintPipeline,
					    FlaxStableDiffusionPipeline,
					)

try:
					if not (is_note_seq_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_note_seq_objects import *  # noqa F403
else:
					from .pipelines import MidiProcessor




