


"""simple docstring"""







import argparse
import os
import shutil
from pathlib import Path

import onnx
import torch
from packaging import version
from torch.onnx import export

from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline


lowerCamelCase_   :   int									=  version.parse(version.parse(torch.__version__).base_version) < version.parse("""1.11""")
def _A						(						lowercase       ,    lowercase       ,    lowercase       ,    lowercase       ,    lowercase       ,    lowercase       ,    lowercase       ,    lowercase=False       ,    ):







    """simple docstring"""
    output_path.parent.mkdir(parents=lowercase       ,    exist_ok=lowercase		)
    # PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11,
    # so we check the torch version for backwards compatibility
    if is_torch_less_than_1_11:
        export(
            lowercase       ,    lowercase       ,    f=output_path.as_posix()       ,    input_names=lowercase       ,    output_names=lowercase       ,    dynamic_axes=lowercase       ,    do_constant_folding=lowercase       ,    use_external_data_format=lowercase       ,    enable_onnx_checker=lowercase       ,    opset_version=lowercase       ,    )
    else:
        export(
            lowercase       ,    lowercase       ,    f=output_path.as_posix()       ,    input_names=lowercase       ,    output_names=lowercase       ,    dynamic_axes=lowercase       ,    do_constant_folding=lowercase       ,    opset_version=lowercase       ,    )
@torch.no_grad()
def _A						(						lowercase       ,    lowercase       ,    lowercase       ,    lowercase = False		):







    """simple docstring"""
    a 		=torch.floataa if fpaa else torch.floataa
    if fpaa and torch.cuda.is_available():
        a 		='''cuda'''
    elif fpaa and not torch.cuda.is_available():
        raise ValueError('''`float16` model export is only supported on GPUs with CUDA'''		)
    else:
        a 		='''cpu'''
    a 		=StableDiffusionPipeline.from_pretrained(lowercase       ,    torch_dtype=lowercase		).to(lowercase		)
    a 		=Path(lowercase		)

    # TEXT ENCODER
    a 		=pipeline.text_encoder.config.max_position_embeddings
    a 		=pipeline.text_encoder.config.hidden_size
    a 		=pipeline.tokenizer(
        '''A sample prompt'''       ,    padding='''max_length'''       ,    max_length=pipeline.tokenizer.model_max_length       ,    truncation=lowercase       ,    return_tensors='''pt'''       ,    )
    onnx_export(
        pipeline.text_encoder       ,    model_args=(text_input.input_ids.to(device=lowercase       ,    dtype=torch.intaa		))       ,    output_path=output_path / '''text_encoder''' / '''model.onnx'''       ,    ordered_input_names=['''input_ids''']       ,    output_names=['''last_hidden_state''', '''pooler_output''']       ,    dynamic_axes={
            '''input_ids''': {0: '''batch''', 1: '''sequence'''},
        }       ,    opset=lowercase       ,    )
    del pipeline.text_encoder

    # UNET
    a 		=pipeline.unet.config.in_channels
    a 		=pipeline.unet.config.sample_size
    a 		=output_path / '''unet''' / '''model.onnx'''
    onnx_export(
        pipeline.unet       ,    model_args=(
            torch.randn(2       ,    lowercase       ,    lowercase       ,    lowercase		).to(device=lowercase       ,    dtype=lowercase		),
            torch.randn(2		).to(device=lowercase       ,    dtype=lowercase		),
            torch.randn(2       ,    lowercase       ,    lowercase		).to(device=lowercase       ,    dtype=lowercase		),
            False,
        )       ,    output_path=lowercase       ,    ordered_input_names=['''sample''', '''timestep''', '''encoder_hidden_states''', '''return_dict''']       ,    output_names=['''out_sample''']       ,    dynamic_axes={
            '''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
            '''timestep''': {0: '''batch'''},
            '''encoder_hidden_states''': {0: '''batch''', 1: '''sequence'''},
        }       ,    opset=lowercase       ,    use_external_data_format=lowercase       ,    )
    a 		=str(unet_path.absolute().as_posix()		)
    a 		=os.path.dirname(lowercase		)
    a 		=onnx.load(lowercase		)
    # clean up existing tensor files
    shutil.rmtree(lowercase		)
    os.mkdir(lowercase		)
    # collate external tensor files into one
    onnx.save_model(
        lowercase       ,    lowercase       ,    save_as_external_data=lowercase       ,    all_tensors_to_one_file=lowercase       ,    location='''weights.pb'''       ,    convert_attribute=lowercase       ,    )
    del pipeline.unet

    # VAE ENCODER
    a 		=pipeline.vae
    a 		=vae_encoder.config.in_channels
    a 		=vae_encoder.config.sample_size
    # need to get the raw tensor output (sample) from the encoder
    a 		=lambda lowercase       ,    lowercase		: vae_encoder.encode(lowercase       ,    lowercase		)[0].sample()
    onnx_export(
        lowercase       ,    model_args=(
            torch.randn(1       ,    lowercase       ,    lowercase       ,    lowercase		).to(device=lowercase       ,    dtype=lowercase		),
            False,
        )       ,    output_path=output_path / '''vae_encoder''' / '''model.onnx'''       ,    ordered_input_names=['''sample''', '''return_dict''']       ,    output_names=['''latent_sample''']       ,    dynamic_axes={
            '''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
        }       ,    opset=lowercase       ,    )

    # VAE DECODER
    a 		=pipeline.vae
    a 		=vae_decoder.config.latent_channels
    a 		=vae_decoder.config.out_channels
    # forward only through the decoder part
    a 		=vae_encoder.decode
    onnx_export(
        lowercase       ,    model_args=(
            torch.randn(1       ,    lowercase       ,    lowercase       ,    lowercase		).to(device=lowercase       ,    dtype=lowercase		),
            False,
        )       ,    output_path=output_path / '''vae_decoder''' / '''model.onnx'''       ,    ordered_input_names=['''latent_sample''', '''return_dict''']       ,    output_names=['''sample''']       ,    dynamic_axes={
            '''latent_sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
        }       ,    opset=lowercase       ,    )
    del pipeline.vae

    # SAFETY CHECKER
    if pipeline.safety_checker is not None:
        a 		=pipeline.safety_checker
        a 		=safety_checker.config.vision_config.num_channels
        a 		=safety_checker.config.vision_config.image_size
        a 		=safety_checker.forward_onnx
        onnx_export(
            pipeline.safety_checker       ,    model_args=(
                torch.randn(
                    1       ,    lowercase       ,    lowercase       ,    lowercase       ,    ).to(device=lowercase       ,    dtype=lowercase		),
                torch.randn(1       ,    lowercase       ,    lowercase       ,    lowercase		).to(device=lowercase       ,    dtype=lowercase		),
            )       ,    output_path=output_path / '''safety_checker''' / '''model.onnx'''       ,    ordered_input_names=['''clip_input''', '''images''']       ,    output_names=['''out_images''', '''has_nsfw_concepts''']       ,    dynamic_axes={
                '''clip_input''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
                '''images''': {0: '''batch''', 1: '''height''', 2: '''width''', 3: '''channels'''},
            }       ,    opset=lowercase       ,    )
        del pipeline.safety_checker
        a 		=OnnxRuntimeModel.from_pretrained(output_path / '''safety_checker'''		)
        a 		=pipeline.feature_extractor
    else:
        a 		=None
        a 		=None

    a 		=OnnxStableDiffusionPipeline(
        vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_encoder'''		)       ,    vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_decoder'''		)       ,    text_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''text_encoder'''		)       ,    tokenizer=pipeline.tokenizer       ,    unet=OnnxRuntimeModel.from_pretrained(output_path / '''unet'''		)       ,    scheduler=pipeline.scheduler       ,    safety_checker=lowercase       ,    feature_extractor=lowercase       ,    requires_safety_checker=safety_checker is not None       ,    )

    onnx_pipeline.save_pretrained(lowercase		)
    print('''ONNX pipeline saved to'''       ,    lowercase		)

    del pipeline
    del onnx_pipeline
    a 		=OnnxStableDiffusionPipeline.from_pretrained(lowercase       ,    provider='''CPUExecutionProvider'''		)
    print('''ONNX pipeline is loadable'''		)


if __name__ == "__main__":
       lowerCamelCase_   :   Tuple									=  argparse.ArgumentParser()

       parser.add_argument(
           """--model_path""",
           type=str,
           required=True,
           help="""Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).""",
       )

       parser.add_argument("""--output_path""", type=str, required=True, help="""Path to the output model.""")

       parser.add_argument(
           """--opset""",
           default=1_4,
           type=int,
           help="""The version of the ONNX operator set to use.""",
       )
       parser.add_argument("""--fp16""", action="""store_true""", default=False, help="""Export the models in `float16` mode""")

       lowerCamelCase_   :   Union[str, Any]									=  parser.parse_args()

       convert_models(args.model_path, args.output_path, args.opset, args.fpaa)
import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowercase							 =					logging.get_logger(__name__)

__lowercase							 =					{
    '''facebook/wav2vec2-base-960h''': '''https://huggingface.co/facebook/wav2vec2-base-960h/resolve/main/config.json''',
    # See all Wav2Vec2 models at https://huggingface.co/models?filter=wav2vec2
}


class 	lowerCamelCase_     (   UpperCAmelCase_ ):






    '''simple docstring'''






    a__	:						Union[str, Any]						=      """wav2vec2"""







    def __init__(	self , __lowercase=32 , __lowercase=768 , __lowercase=12 , __lowercase=12 , __lowercase=3_072 , __lowercase="gelu" , __lowercase=0.1 , __lowercase=0.1 , __lowercase=0.1 , __lowercase=0.0 , __lowercase=0.0 , __lowercase=0.1 , __lowercase=0.1 , __lowercase=0.02 , __lowercase=1E-5 , __lowercase="group" , __lowercase="gelu" , __lowercase=(512, 512, 512, 512, 512, 512, 512) , __lowercase=(5, 2, 2, 2, 2, 2, 2) , __lowercase=(10, 3, 3, 3, 3, 2, 2) , __lowercase=False , __lowercase=128 , __lowercase=16 , __lowercase=False , __lowercase=True , __lowercase=0.05 , __lowercase=10 , __lowercase=2 , __lowercase=0.0 , __lowercase=10 , __lowercase=0 , __lowercase=320 , __lowercase=2 , __lowercase=0.1 , __lowercase=100 , __lowercase=256 , __lowercase=256 , __lowercase=0.1 , __lowercase="sum" , __lowercase=False , __lowercase=False , __lowercase=256 , __lowercase=(512, 512, 512, 512, 1_500) , __lowercase=(5, 3, 3, 1, 1) , __lowercase=(1, 2, 3, 1, 1) , __lowercase=512 , __lowercase=0 , __lowercase=1 , __lowercase=2 , __lowercase=False , __lowercase=3 , __lowercase=2 , __lowercase=3 , __lowercase=None , __lowercase=None , **__lowercase , )       ->	int:
        super().__init__(**__lowercase , pad_token_id=__lowercase , bos_token_id=__lowercase , eos_token_id=__lowercase)
        __UpperCamelCase     :Any			  =		hidden_size
        __UpperCamelCase     :int			  =		feat_extract_norm
        __UpperCamelCase     :Tuple			  =		feat_extract_activation
        __UpperCamelCase     :Union[str, Any]			  =		list(__lowercase)
        __UpperCamelCase     :List[Any]			  =		list(__lowercase)
        __UpperCamelCase     :int			  =		list(__lowercase)
        __UpperCamelCase     :List[Any]			  =		conv_bias
        __UpperCamelCase     :Optional[int]			  =		num_conv_pos_embeddings
        __UpperCamelCase     :Dict			  =		num_conv_pos_embedding_groups
        __UpperCamelCase     :Any			  =		len(self.conv_dim)
        __UpperCamelCase     :List[str]			  =		num_hidden_layers
        __UpperCamelCase     :int			  =		intermediate_size
        __UpperCamelCase     :str			  =		hidden_act
        __UpperCamelCase     :Any			  =		num_attention_heads
        __UpperCamelCase     :int			  =		hidden_dropout
        __UpperCamelCase     :Tuple			  =		attention_dropout
        __UpperCamelCase     :List[str]			  =		activation_dropout
        __UpperCamelCase     :Optional[Any]			  =		feat_proj_dropout
        __UpperCamelCase     :Any			  =		final_dropout
        __UpperCamelCase     :Any			  =		layerdrop
        __UpperCamelCase     :str			  =		layer_norm_eps
        __UpperCamelCase     :Optional[Any]			  =		initializer_range
        __UpperCamelCase     :List[str]			  =		vocab_size
        __UpperCamelCase     :str			  =		do_stable_layer_norm
        __UpperCamelCase     :Union[str, Any]			  =		use_weighted_layer_sum

        if (
            (len(self.conv_stride) != self.num_feat_extract_layers)
            or (len(self.conv_kernel) != self.num_feat_extract_layers)
            or (len(self.conv_dim) != self.num_feat_extract_layers)
        ):
            raise ValueError(
                '''Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='''
                ''' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='''
                f""" {len(self.conv_dim)}`, `len(config.conv_stride) = {len(self.conv_stride)}`,"""
                f""" `len(config.conv_kernel) = {len(self.conv_kernel)}`.""")

        # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
        __UpperCamelCase     :List[Any]			  =		apply_spec_augment
        __UpperCamelCase     :Tuple			  =		mask_time_prob
        __UpperCamelCase     :int			  =		mask_time_length
        __UpperCamelCase     :Dict			  =		mask_time_min_masks
        __UpperCamelCase     :str			  =		mask_feature_prob
        __UpperCamelCase     :List[str]			  =		mask_feature_length
        __UpperCamelCase     :Union[str, Any]			  =		mask_feature_min_masks

        # parameters for pretraining with codevector quantized representations
        __UpperCamelCase     :Optional[Any]			  =		num_codevectors_per_group
        __UpperCamelCase     :List[Any]			  =		num_codevector_groups
        __UpperCamelCase     :Tuple			  =		contrastive_logits_temperature
        __UpperCamelCase     :Optional[int]			  =		feat_quantizer_dropout
        __UpperCamelCase     :Optional[int]			  =		num_negatives
        __UpperCamelCase     :List[Any]			  =		codevector_dim
        __UpperCamelCase     :str			  =		proj_codevector_dim
        __UpperCamelCase     :List[str]			  =		diversity_loss_weight

        # ctc loss
        __UpperCamelCase     :Tuple			  =		ctc_loss_reduction
        __UpperCamelCase     :Tuple			  =		ctc_zero_infinity

        # adapter
        __UpperCamelCase     :List[str]			  =		add_adapter
        __UpperCamelCase     :Tuple			  =		adapter_kernel_size
        __UpperCamelCase     :str			  =		adapter_stride
        __UpperCamelCase     :Tuple			  =		num_adapter_layers
        __UpperCamelCase     :Tuple			  =		output_hidden_size or hidden_size
        __UpperCamelCase     :Optional[Any]			  =		adapter_attn_dim

        # SequenceClassification-specific parameter. Feel free to ignore for other classes.
        __UpperCamelCase     :Optional[Any]			  =		classifier_proj_size

        # XVector-specific parameters. Feel free to ignore for other classes.
        __UpperCamelCase     :Optional[int]			  =		list(__lowercase)
        __UpperCamelCase     :List[Any]			  =		list(__lowercase)
        __UpperCamelCase     :List[Any]			  =		list(__lowercase)
        __UpperCamelCase     :str			  =		xvector_output_dim







    @property
    def 			UpperCamelCase__   (	self)       ->	List[str]:
        return functools.reduce(operator.mul , self.conv_stride , 1)





