
import argparse
import math
import os
from copy import deepcopy

import torch
from audio_diffusion.models import DiffusionAttnUnetaD
from diffusion import sampling
from torch import nn

from diffusers import DanceDiffusionPipeline, IPNDMScheduler, UNetaDModel


__lowerCAmelCase					:			List[str]			      =		{
    "gwf-440k": {
        "url": "https://model-server.zqevans2.workers.dev/gwf-440k.ckpt",
        "sample_rate": 48_000,
        "sample_size": 65_536,
    },
    "jmann-small-190k": {
        "url": "https://model-server.zqevans2.workers.dev/jmann-small-190k.ckpt",
        "sample_rate": 48_000,
        "sample_size": 65_536,
    },
    "jmann-large-580k": {
        "url": "https://model-server.zqevans2.workers.dev/jmann-large-580k.ckpt",
        "sample_rate": 48_000,
        "sample_size": 131_072,
    },
    "maestro-uncond-150k": {
        "url": "https://model-server.zqevans2.workers.dev/maestro-uncond-150k.ckpt",
        "sample_rate": 16_000,
        "sample_size": 65_536,
    },
    "unlocked-uncond-250k": {
        "url": "https://model-server.zqevans2.workers.dev/unlocked-uncond-250k.ckpt",
        "sample_rate": 16_000,
        "sample_size": 65_536,
    },
    "honk-140k": {
        "url": "https://model-server.zqevans2.workers.dev/honk-140k.ckpt",
        "sample_rate": 16_000,
        "sample_size": 65_536,
    },
}


def     UpperCAmelCase_  (						__lowerCAmelCase	,					__lowerCAmelCase	) ->						Tuple:
    return torch.atana(__lowerCAmelCase	,					__lowerCAmelCase	) / math.pi * 2


def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						Tuple:
    __lowercase		:			List[Any]	    =       torch.sin(t * math.pi / 2	) ** 2
    __lowercase		:			str	    =       (1 - sigma**2) ** 0.5
    return alpha_sigma_to_t(__lowerCAmelCase	,					__lowerCAmelCase	)


class 						__lowerCAmelCase	(	lowerCAmelCase_      ):



      """simple docstring"""







      pass






class 						__lowerCAmelCase	(	nn.Module      ):



      """simple docstring"""







      def __init__(      self		:       List[str]				,       _snake_case		:       Optional[Any]				):
          super().__init__()

          __lowercase		:			Any	    =       DiffusionAttnUnetaD(_snake_case				,       n_attn_layers=4				)
          __lowercase		:			int	    =       deepcopy(self.diffusion				)
          __lowercase		:			List[str]	    =       torch.quasirandom.SobolEngine(1				,       scramble=_snake_case				)






def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						int:
    __lowercase		:			List[str]	    =       MODELS_MAP[model_name]['''url''']
    os.system(F'wget {url} ./'	)

    return F'./{model_name}.ckpt'


__lowerCAmelCase					:			str			      =		{
    "1": "resnets.0",
    "2": "attentions.0",
    "3": "resnets.1",
    "4": "attentions.1",
    "5": "resnets.2",
    "6": "attentions.2",
}
__lowerCAmelCase					:			Tuple			      =		{
    "8": "resnets.0",
    "9": "attentions.0",
    "10": "resnets.1",
    "11": "attentions.1",
    "12": "resnets.2",
    "13": "attentions.2",
}
__lowerCAmelCase					:			Any			      =		{
    "1": "resnets.0",
    "2": "attentions.0",
    "3": "resnets.1",
    "4": "attentions.1",
    "5": "resnets.2",
    "6": "attentions.2",
    "8": "resnets.3",
    "9": "attentions.3",
    "10": "resnets.4",
    "11": "attentions.4",
    "12": "resnets.5",
    "13": "attentions.5",
}
__lowerCAmelCase					:			int			      =		{
    "0": "resnets.0",
    "1": "resnets.1",
    "2": "resnets.2",
    "4": "resnets.0",
    "5": "resnets.1",
    "6": "resnets.2",
}

__lowerCAmelCase					:			Optional[Any]			      =		{
    "skip": "conv_skip",
    "main.0": "conv_1",
    "main.1": "group_norm_1",
    "main.3": "conv_2",
    "main.4": "group_norm_2",
}

__lowerCAmelCase					:			Dict			      =		{
    "norm": "group_norm",
    "qkv_proj": ["query", "key", "value"],
    "out_proj": ["proj_attn"],
}


def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						str:
    if name.startswith('''skip'''	):
        return name.replace('''skip'''	,					RES_CONV_MAP['''skip''']	)

    # name has to be of format main.{digit}
    if not name.startswith('''main.'''	):
        raise ValueError(F'ResConvBlock error with {name}'	)

    return name.replace(name[:6]	,					RES_CONV_MAP[name[:6]]	)


def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						Optional[int]:
    for key, value in ATTN_MAP.items():
        if name.startswith(__lowerCAmelCase	) and not isinstance(__lowerCAmelCase	,					__lowerCAmelCase	):
            return name.replace(__lowerCAmelCase	,					__lowerCAmelCase	)
        elif name.startswith(__lowerCAmelCase	):
            return [name.replace(__lowerCAmelCase	,					__lowerCAmelCase	) for v in value]
    raise ValueError(F'Attn error with {name}'	)


def     UpperCAmelCase_  (						__lowerCAmelCase	,					__lowerCAmelCase=13	) ->						Optional[int]:
    __lowercase		:			int	    =       input_string

    if string.split('''.'''	)[0] == "timestep_embed":
        return string.replace('''timestep_embed'''	,					'''time_proj'''	)

    __lowercase		:			int	    =       0
    if string.startswith('''net.3.'''	):
        depth += 1
        __lowercase		:			Optional[int]	    =       string[6:]
    elif string.startswith('''net.'''	):
        __lowercase		:			int	    =       string[4:]

    while string.startswith('''main.7.'''	):
        depth += 1
        __lowercase		:			Tuple	    =       string[7:]

    if string.startswith('''main.'''	):
        __lowercase		:			Tuple	    =       string[5:]

    # mid block
    if string[:2].isdigit():
        __lowercase		:			Tuple	    =       string[:2]
        __lowercase		:			Union[str, Any]	    =       string[2:]
    else:
        __lowercase		:			int	    =       string[0]
        __lowercase		:			Optional[int]	    =       string[1:]

    if depth == max_depth:
        __lowercase		:			Optional[int]	    =       MID_NUM_TO_LAYER[layer_num]
        __lowercase		:			Union[str, Any]	    =       '''mid_block'''
    elif depth > 0 and int(__lowerCAmelCase	) < 7:
        __lowercase		:			int	    =       DOWN_NUM_TO_LAYER[layer_num]
        __lowercase		:			List[Any]	    =       F'down_blocks.{depth}'
    elif depth > 0 and int(__lowerCAmelCase	) > 7:
        __lowercase		:			int	    =       UP_NUM_TO_LAYER[layer_num]
        __lowercase		:			str	    =       F'up_blocks.{max_depth - depth - 1}'
    elif depth == 0:
        __lowercase		:			Any	    =       DEPTH_0_TO_LAYER[layer_num]
        __lowercase		:			Optional[int]	    =       F'up_blocks.{max_depth - 1}' if int(__lowerCAmelCase	) > 3 else '''down_blocks.0'''

    if not string_left.startswith('''.'''	):
        raise ValueError(F'Naming error with {input_string} and string_left: {string_left}.'	)

    __lowercase		:			Dict	    =       string_left[1:]

    if "resnets" in new_layer:
        __lowercase		:			List[Any]	    =       convert_resconv_naming(__lowerCAmelCase	)
    elif "attentions" in new_layer:
        __lowercase		:			Dict	    =       convert_attn_naming(__lowerCAmelCase	)
        __lowercase		:			str	    =       new_string_left

    if not isinstance(__lowerCAmelCase	,					__lowerCAmelCase	):
        __lowercase		:			int	    =       prefix + '''.''' + new_layer + '''.''' + string_left
    else:
        __lowercase		:			List[Any]	    =       [prefix + '''.''' + new_layer + '''.''' + s for s in string_left]
    return new_string


def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						int:
    __lowercase		:			str	    =       {}
    for k, v in state_dict.items():
        if k.endswith('''kernel'''	):
            # up- and downsample layers, don't have trainable weights
            continue

        __lowercase		:			Optional[Any]	    =       rename(__lowerCAmelCase	)

        # check if we need to transform from Conv => Linear for attention
        if isinstance(__lowerCAmelCase	,					__lowerCAmelCase	):
            __lowercase		:			List[Any]	    =       transform_conv_attns(__lowerCAmelCase	,					__lowerCAmelCase	,					__lowerCAmelCase	)
        else:
            __lowercase		:			Tuple	    =       v

    return new_state_dict


def     UpperCAmelCase_  (						__lowerCAmelCase	,					__lowerCAmelCase	,					__lowerCAmelCase	) ->						int:
    if len(__lowerCAmelCase	) == 1:
        if len(v.shape	) == 3:
            # weight
            __lowercase		:			Optional[int]	    =       v[:, :, 0]
        else:
            # bias
            __lowercase		:			List[Any]	    =       v
    else:
        # qkv matrices
        __lowercase		:			Dict	    =       v.shape[0]
        __lowercase		:			Dict	    =       trippled_shape // 3
        for i in range(3	):
            if len(v.shape	) == 3:
                __lowercase		:			Optional[Any]	    =       v[i * single_shape : (i + 1) * single_shape, :, 0]
            else:
                __lowercase		:			str	    =       v[i * single_shape : (i + 1) * single_shape]
    return new_state_dict


def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						Tuple:
    __lowercase		:			Optional[Any]	    =       torch.device('''cuda''' if torch.cuda.is_available() else '''cpu'''	)

    __lowercase		:			List[Any]	    =       args.model_path.split('''/'''	)[-1].split('''.'''	)[0]
    if not os.path.isfile(args.model_path	):
        assert (
            model_name == args.model_path
        ), F'Make sure to provide one of the official model names {MODELS_MAP.keys()}'
        __lowercase		:			List[str]	    =       download(__lowerCAmelCase	)

    __lowercase		:			List[str]	    =       MODELS_MAP[model_name]['''sample_rate''']
    __lowercase		:			Union[str, Any]	    =       MODELS_MAP[model_name]['''sample_size''']

    __lowercase		:			int	    =       Object()
    __lowercase		:			Union[str, Any]	    =       sample_size
    __lowercase		:			Any	    =       sample_rate
    __lowercase		:			Union[str, Any]	    =       0

    __lowercase		:			Dict	    =       UNetaDModel(sample_size=__lowerCAmelCase	,					sample_rate=__lowerCAmelCase	)
    __lowercase		:			Optional[Any]	    =       diffusers_model.state_dict()

    __lowercase		:			Any	    =       DiffusionUncond(__lowerCAmelCase	)
    orig_model.load_state_dict(torch.load(args.model_path	,					map_location=__lowerCAmelCase	)['''state_dict''']	)
    __lowercase		:			List[str]	    =       orig_model.diffusion_ema.eval()
    __lowercase		:			List[str]	    =       orig_model.state_dict()
    __lowercase		:			Union[str, Any]	    =       rename_orig_weights(__lowerCAmelCase	)

    __lowercase		:			List[Any]	    =       set(renamed_state_dict.keys()	) - set(diffusers_state_dict.keys()	)
    __lowercase		:			List[str]	    =       set(diffusers_state_dict.keys()	) - set(renamed_state_dict.keys()	)

    assert len(__lowerCAmelCase	) == 0, F'Problem with {renamed_minus_diffusers}'
    assert all(k.endswith('''kernel'''	) for k in list(__lowerCAmelCase	)	), F'Problem with {diffusers_minus_renamed}'

    for key, value in renamed_state_dict.items():
        assert (
            diffusers_state_dict[key].squeeze().shape == value.squeeze().shape
        ), F'Shape for {key} doesn\'t match. Diffusers: {diffusers_state_dict[key].shape} vs. {value.shape}'
        if key == "time_proj.weight":
            __lowercase		:			Optional[int]	    =       value.squeeze()

        __lowercase		:			int	    =       value

    diffusers_model.load_state_dict(__lowerCAmelCase	)

    __lowercase		:			Optional[int]	    =       100
    __lowercase		:			Optional[Any]	    =       33

    __lowercase		:			Tuple	    =       IPNDMScheduler(num_train_timesteps=__lowerCAmelCase	)

    __lowercase		:			str	    =       torch.manual_seed(__lowerCAmelCase	)
    __lowercase		:			List[str]	    =       torch.randn([1, 2, config.sample_size]	,					generator=__lowerCAmelCase	).to(__lowerCAmelCase	)

    __lowercase		:			Optional[Any]	    =       torch.linspace(1	,					0	,					steps + 1	,					device=__lowerCAmelCase	)[:-1]
    __lowercase		:			int	    =       get_crash_schedule(__lowerCAmelCase	)

    __lowercase		:			List[Any]	    =       DanceDiffusionPipeline(unet=__lowerCAmelCase	,					scheduler=__lowerCAmelCase	)

    __lowercase		:			List[Any]	    =       torch.manual_seed(33	)
    __lowercase		:			List[str]	    =       pipe(num_inference_steps=__lowerCAmelCase	,					generator=__lowerCAmelCase	).audios

    __lowercase		:			List[str]	    =       sampling.iplms_sample(__lowerCAmelCase	,					__lowerCAmelCase	,					__lowerCAmelCase	,					{}	)
    __lowercase		:			Optional[Any]	    =       generated.clamp(-1	,					1	)

    __lowercase		:			Union[str, Any]	    =       (generated - audio).abs().sum()
    __lowercase		:			Dict	    =       (generated - audio).abs().max()

    if args.save:
        pipe.save_pretrained(args.checkpoint_path	)

    print('''Diff sum'''	,					__lowerCAmelCase	)
    print('''Diff max'''	,					__lowerCAmelCase	)

    assert diff_max < 1E-3, F'Diff max: {diff_max} is too much :-/'

    print(F'Conversion for {model_name} successful!'	)


if __name__ == "__main__":
 __lowerCAmelCase					:			Optional[int]			      =		argparse.ArgumentParser()

 parser.add_argument("--model_path", default=None, type=str, required=True, help="Path to the model to convert.")
 parser.add_argument(
     "--save", default=True, type=bool, required=False, help="Whether to save the converted model or not."
 )
 parser.add_argument("--checkpoint_path", default=None, type=str, required=True, help="Path to the output model.")
 __lowerCAmelCase					:			List[str]			      =		parser.parse_args()

 main(args)




import json
import os
import pickle
import shutil
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
from datasets import Dataset

from transformers import is_faiss_available
from transformers.models.bart.configuration_bart import BartConfig
from transformers.models.bart.tokenization_bart import BartTokenizer
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.dpr.configuration_dpr import DPRConfig
from transformers.models.dpr.tokenization_dpr import DPRContextEncoderTokenizer, DPRQuestionEncoderTokenizer
from transformers.models.rag.configuration_rag import RagConfig
from transformers.models.rag.retrieval_rag import CustomHFIndex, RagRetriever
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_faiss, require_sentencepiece, require_tokenizers, require_torch


if is_faiss_available():
 import faiss


@require_faiss
class 						__lowerCAmelCase	(	lowerCAmelCase_      ):



      """simple docstring"""







      def 		snake_case_			(      self		:       Optional[int]				):
          __lowercase		:			Dict	    =       tempfile.mkdtemp()
          __lowercase		:			Tuple	    =       8

          # DPR tok
          __lowercase		:			Optional[int]	    =       [
              '''[UNK]''',
              '''[CLS]''',
              '''[SEP]''',
              '''[PAD]''',
              '''[MASK]''',
              '''want''',
              '''##want''',
              '''##ed''',
              '''wa''',
              '''un''',
              '''runn''',
              '''##ing''',
              ''',''',
              '''low''',
              '''lowest''',
          ]
          __lowercase		:			Optional[Any]	    =       os.path.join(self.tmpdirname				,       '''dpr_tokenizer'''				)
          os.makedirs(_snake_case				,       exist_ok=_snake_case				)
          __lowercase		:			str	    =       os.path.join(_snake_case				,       DPR_VOCAB_FILES_NAMES['''vocab_file''']				)
          with open(self.vocab_file				,       '''w'''				,       encoding='''utf-8'''				) as vocab_writer:
              vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]				)				)

          # BART tok
          __lowercase		:			List[str]	    =       [
              '''l''',
              '''o''',
              '''w''',
              '''e''',
              '''r''',
              '''s''',
              '''t''',
              '''i''',
              '''d''',
              '''n''',
              '''\u0120''',
              '''\u0120l''',
              '''\u0120n''',
              '''\u0120lo''',
              '''\u0120low''',
              '''er''',
              '''\u0120lowest''',
              '''\u0120newer''',
              '''\u0120wider''',
              '''<unk>''',
          ]
          __lowercase		:			Optional[Any]	    =       dict(zip(_snake_case				,       range(len(_snake_case				)				)				)				)
          __lowercase		:			int	    =       ['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
          __lowercase		:			Any	    =       {'''unk_token''': '''<unk>'''}

          __lowercase		:			int	    =       os.path.join(self.tmpdirname				,       '''bart_tokenizer'''				)
          os.makedirs(_snake_case				,       exist_ok=_snake_case				)
          __lowercase		:			List[Any]	    =       os.path.join(_snake_case				,       BART_VOCAB_FILES_NAMES['''vocab_file''']				)
          __lowercase		:			Tuple	    =       os.path.join(_snake_case				,       BART_VOCAB_FILES_NAMES['''merges_file''']				)
          with open(self.vocab_file				,       '''w'''				,       encoding='''utf-8'''				) as fp:
              fp.write(json.dumps(_snake_case				) + '''\n'''				)
          with open(self.merges_file				,       '''w'''				,       encoding='''utf-8'''				) as fp:
              fp.write('''\n'''.join(_snake_case				)				)




      def 		snake_case_			(      self		:       List[Any]				):
          return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname				,       '''dpr_tokenizer'''				)				)




      def 		snake_case_			(      self		:       Dict				):
          return DPRContextEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname				,       '''dpr_tokenizer'''				)				)




      def 		snake_case_			(      self		:       Optional[int]				):
          return BartTokenizer.from_pretrained(os.path.join(self.tmpdirname				,       '''bart_tokenizer'''				)				)




      def 		snake_case_			(      self		:       str				):
          shutil.rmtree(self.tmpdirname				)




      def 		snake_case_			(      self		:       Tuple				):
          __lowercase		:			Dict	    =       Dataset.from_dict(
              {
                  '''id''': ['''0''', '''1'''],
                  '''text''': ['''foo''', '''bar'''],
                  '''title''': ['''Foo''', '''Bar'''],
                  '''embeddings''': [np.ones(self.retrieval_vector_size				), 2 * np.ones(self.retrieval_vector_size				)],
              }				)
          dataset.add_faiss_index('''embeddings'''				,       string_factory='''Flat'''				,       metric_type=faiss.METRIC_INNER_PRODUCT				)
          return dataset




      def 		snake_case_			(      self		:       Union[str, Any]				):
          __lowercase		:			Union[str, Any]	    =       self.get_dummy_dataset()
          __lowercase		:			Optional[int]	    =       RagConfig(
              retrieval_vector_size=self.retrieval_vector_size				,       question_encoder=DPRConfig().to_dict()				,       generator=BartConfig().to_dict()				,       )
          with patch('''transformers.models.rag.retrieval_rag.load_dataset'''				) as mock_load_dataset:
              __lowercase		:			List[Any]	    =       dataset
              __lowercase		:			str	    =       RagRetriever(
                  _snake_case				,       question_encoder_tokenizer=self.get_dpr_tokenizer()				,       generator_tokenizer=self.get_bart_tokenizer()				,       )
          return retriever




      def 		snake_case_			(      self		:       int				,       _snake_case		:       bool				):
          __lowercase		:			Dict	    =       self.get_dummy_dataset()
          __lowercase		:			List[Any]	    =       RagConfig(
              retrieval_vector_size=self.retrieval_vector_size				,       question_encoder=DPRConfig().to_dict()				,       generator=BartConfig().to_dict()				,       index_name='''custom'''				,       )
          if from_disk:
              __lowercase		:			List[Any]	    =       os.path.join(self.tmpdirname				,       '''dataset'''				)
              __lowercase		:			Union[str, Any]	    =       os.path.join(self.tmpdirname				,       '''index.faiss'''				)
              dataset.get_index('''embeddings'''				).save(os.path.join(self.tmpdirname				,       '''index.faiss'''				)				)
              dataset.drop_index('''embeddings'''				)
              dataset.save_to_disk(os.path.join(self.tmpdirname				,       '''dataset'''				)				)
              del dataset
              __lowercase		:			Optional[Any]	    =       RagRetriever(
                  _snake_case				,       question_encoder_tokenizer=self.get_dpr_tokenizer()				,       generator_tokenizer=self.get_bart_tokenizer()				,       )
          else:
              __lowercase		:			Optional[Any]	    =       RagRetriever(
                  _snake_case				,       question_encoder_tokenizer=self.get_dpr_tokenizer()				,       generator_tokenizer=self.get_bart_tokenizer()				,       index=CustomHFIndex(config.retrieval_vector_size				,       _snake_case				)				,       )
          return retriever




      def 		snake_case_			(      self		:       str				):
          __lowercase		:			List[str]	    =       Dataset.from_dict(
              {
                  '''id''': ['''0''', '''1'''],
                  '''text''': ['''foo''', '''bar'''],
                  '''title''': ['''Foo''', '''Bar'''],
                  '''embeddings''': [np.ones(self.retrieval_vector_size + 1				), 2 * np.ones(self.retrieval_vector_size + 1				)],
              }				)
          dataset.add_faiss_index('''embeddings'''				,       string_factory='''Flat'''				,       metric_type=faiss.METRIC_INNER_PRODUCT				)

          __lowercase		:			Optional[int]	    =       os.path.join(self.tmpdirname				,       '''hf_bert_base.hnswSQ8_correct_phi_128.c_index'''				)
          dataset.save_faiss_index('''embeddings'''				,       index_file_name + '''.index.dpr'''				)
          pickle.dump(dataset['''id''']				,       open(index_file_name + '''.index_meta.dpr'''				,       '''wb'''				)				)

          __lowercase		:			str	    =       os.path.join(self.tmpdirname				,       '''psgs_w100.tsv.pkl'''				)
          __lowercase		:			Dict	    =       {sample['''id''']: [sample['''text'''], sample['''title''']] for sample in dataset}
          pickle.dump(_snake_case				,       open(_snake_case				,       '''wb'''				)				)

          __lowercase		:			List[str]	    =       RagConfig(
              retrieval_vector_size=self.retrieval_vector_size				,       question_encoder=DPRConfig().to_dict()				,       generator=BartConfig().to_dict()				,       index_name='''legacy'''				,       index_path=self.tmpdirname				,       )
          __lowercase		:			Optional[int]	    =       RagRetriever(
              _snake_case				,       question_encoder_tokenizer=self.get_dpr_tokenizer()				,       generator_tokenizer=self.get_bart_tokenizer()				)
          return retriever




      def 		snake_case_			(      self		:       Optional[Any]				):
          __lowercase		:			List[str]	    =       1
          __lowercase		:			Tuple	    =       self.get_dummy_canonical_hf_index_retriever()
          __lowercase		:			List[Any]	    =       np.array(
              [np.ones(self.retrieval_vector_size				), -np.ones(self.retrieval_vector_size				)]				,       dtype=np.floataa				)
          __lowercase    ,      __lowercase    ,      __lowercase		:			str	    =       retriever.retrieve(_snake_case				,       n_docs=_snake_case				)
          self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)				)
          self.assertEqual(len(_snake_case				)				,       2				)
          self.assertEqual(sorted(doc_dicts[0]				)				,       ['''embeddings''', '''id''', '''text''', '''title''']				)
          self.assertEqual(len(doc_dicts[0]['''id''']				)				,       _snake_case				)
          self.assertEqual(doc_dicts[0]['''id'''][0]				,       '''1'''				)  # max inner product is reached with second doc
          self.assertEqual(doc_dicts[1]['''id'''][0]				,       '''0'''				)  # max inner product is reached with first doc
          self.assertListEqual(doc_ids.tolist()				,       [[1], [0]]				)




      def 		snake_case_			(      self		:       int				):
          __lowercase		:			int	    =       self.get_dummy_canonical_hf_index_retriever()
          with tempfile.TemporaryDirectory() as tmp_dirname:
              with patch('''transformers.models.rag.retrieval_rag.load_dataset'''				) as mock_load_dataset:
                  __lowercase		:			Optional[Any]	    =       self.get_dummy_dataset()
                  retriever.save_pretrained(_snake_case				)
                  __lowercase		:			str	    =       RagRetriever.from_pretrained(_snake_case				)
                  self.assertIsInstance(_snake_case				,       _snake_case				)
                  __lowercase		:			List[str]	    =       np.array(
                      [np.ones(self.retrieval_vector_size				), -np.ones(self.retrieval_vector_size				)]				,       dtype=np.floataa				)
                  __lowercase		:			Union[str, Any]	    =       retriever.retrieve(_snake_case				,       n_docs=1				)
                  self.assertTrue(out is not None				)




      def 		snake_case_			(      self		:       str				):
          __lowercase		:			List[str]	    =       1
          __lowercase		:			Dict	    =       self.get_dummy_custom_hf_index_retriever(from_disk=_snake_case				)
          __lowercase		:			Optional[Any]	    =       np.array(
              [np.ones(self.retrieval_vector_size				), -np.ones(self.retrieval_vector_size				)]				,       dtype=np.floataa				)
          __lowercase    ,      __lowercase    ,      __lowercase		:			Tuple	    =       retriever.retrieve(_snake_case				,       n_docs=_snake_case				)
          self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)				)
          self.assertEqual(len(_snake_case				)				,       2				)
          self.assertEqual(sorted(doc_dicts[0]				)				,       ['''embeddings''', '''id''', '''text''', '''title''']				)
          self.assertEqual(len(doc_dicts[0]['''id''']				)				,       _snake_case				)
          self.assertEqual(doc_dicts[0]['''id'''][0]				,       '''1'''				)  # max inner product is reached with second doc
          self.assertEqual(doc_dicts[1]['''id'''][0]				,       '''0'''				)  # max inner product is reached with first doc
          self.assertListEqual(doc_ids.tolist()				,       [[1], [0]]				)




      def 		snake_case_			(      self		:       Any				):
          __lowercase		:			List[str]	    =       self.get_dummy_custom_hf_index_retriever(from_disk=_snake_case				)
          with tempfile.TemporaryDirectory() as tmp_dirname:
              retriever.save_pretrained(_snake_case				)
              __lowercase		:			Optional[Any]	    =       RagRetriever.from_pretrained(_snake_case				)
              self.assertIsInstance(_snake_case				,       _snake_case				)
              __lowercase		:			Optional[Any]	    =       np.array(
                  [np.ones(self.retrieval_vector_size				), -np.ones(self.retrieval_vector_size				)]				,       dtype=np.floataa				)
              __lowercase		:			List[Any]	    =       retriever.retrieve(_snake_case				,       n_docs=1				)
              self.assertTrue(out is not None				)




      def 		snake_case_			(      self		:       List[Any]				):
          __lowercase		:			Any	    =       1
          __lowercase		:			List[Any]	    =       self.get_dummy_custom_hf_index_retriever(from_disk=_snake_case				)
          __lowercase		:			Any	    =       np.array(
              [np.ones(self.retrieval_vector_size				), -np.ones(self.retrieval_vector_size				)]				,       dtype=np.floataa				)
          __lowercase    ,      __lowercase    ,      __lowercase		:			Union[str, Any]	    =       retriever.retrieve(_snake_case				,       n_docs=_snake_case				)
          self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)				)
          self.assertEqual(len(_snake_case				)				,       2				)
          self.assertEqual(sorted(doc_dicts[0]				)				,       ['''embeddings''', '''id''', '''text''', '''title''']				)
          self.assertEqual(len(doc_dicts[0]['''id''']				)				,       _snake_case				)
          self.assertEqual(doc_dicts[0]['''id'''][0]				,       '''1'''				)  # max inner product is reached with second doc
          self.assertEqual(doc_dicts[1]['''id'''][0]				,       '''0'''				)  # max inner product is reached with first doc
          self.assertListEqual(doc_ids.tolist()				,       [[1], [0]]				)




      def 		snake_case_			(      self		:       Any				):
          __lowercase		:			str	    =       self.get_dummy_custom_hf_index_retriever(from_disk=_snake_case				)
          with tempfile.TemporaryDirectory() as tmp_dirname:
              retriever.save_pretrained(_snake_case				)
              __lowercase		:			Optional[int]	    =       RagRetriever.from_pretrained(_snake_case				)
              self.assertIsInstance(_snake_case				,       _snake_case				)
              __lowercase		:			Union[str, Any]	    =       np.array(
                  [np.ones(self.retrieval_vector_size				), -np.ones(self.retrieval_vector_size				)]				,       dtype=np.floataa				)
              __lowercase		:			Tuple	    =       retriever.retrieve(_snake_case				,       n_docs=1				)
              self.assertTrue(out is not None				)




      def 		snake_case_			(      self		:       Tuple				):
          __lowercase		:			Optional[int]	    =       1
          __lowercase		:			str	    =       self.get_dummy_legacy_index_retriever()
          __lowercase		:			Tuple	    =       np.array(
              [np.ones(self.retrieval_vector_size				), -np.ones(self.retrieval_vector_size				)]				,       dtype=np.floataa				)
          __lowercase    ,      __lowercase    ,      __lowercase		:			Tuple	    =       retriever.retrieve(_snake_case				,       n_docs=_snake_case				)
          self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)				)
          self.assertEqual(len(_snake_case				)				,       2				)
          self.assertEqual(sorted(doc_dicts[0]				)				,       ['''text''', '''title''']				)
          self.assertEqual(len(doc_dicts[0]['''text''']				)				,       _snake_case				)
          self.assertEqual(doc_dicts[0]['''text'''][0]				,       '''bar'''				)  # max inner product is reached with second doc
          self.assertEqual(doc_dicts[1]['''text'''][0]				,       '''foo'''				)  # max inner product is reached with first doc
          self.assertListEqual(doc_ids.tolist()				,       [[1], [0]]				)




      def 		snake_case_			(      self		:       Union[str, Any]				):
          __lowercase		:			Tuple	    =       self.get_dummy_legacy_index_retriever()
          with tempfile.TemporaryDirectory() as tmp_dirname:
              retriever.save_pretrained(_snake_case				)
              __lowercase		:			Tuple	    =       RagRetriever.from_pretrained(_snake_case				)
              self.assertIsInstance(_snake_case				,       _snake_case				)
              __lowercase		:			Optional[int]	    =       np.array(
                  [np.ones(self.retrieval_vector_size				), -np.ones(self.retrieval_vector_size				)]				,       dtype=np.floataa				)
              __lowercase		:			Tuple	    =       retriever.retrieve(_snake_case				,       n_docs=1				)
              self.assertTrue(out is not None				)




      @require_torch
      @require_tokenizers
      @require_sentencepiece
      def 		snake_case_			(      self		:       Optional[Any]				):
          import torch

          __lowercase		:			Tuple	    =       1
          __lowercase		:			Any	    =       self.get_dummy_canonical_hf_index_retriever()
          __lowercase		:			str	    =       [[5, 7], [10, 11]]
          __lowercase		:			List[Any]	    =       np.array(
              [np.ones(self.retrieval_vector_size				), -np.ones(self.retrieval_vector_size				)]				,       dtype=np.floataa				)
          __lowercase		:			Any	    =       retriever(_snake_case				,       _snake_case				,       prefix=retriever.config.generator.prefix				,       n_docs=_snake_case				)
          __lowercase    ,      __lowercase    ,      __lowercase		:			Tuple	    =       (
              out['''context_input_ids'''],
              out['''context_attention_mask'''],
              out['''retrieved_doc_embeds'''],
          )
          self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)				)
          self.assertIsInstance(_snake_case				,       _snake_case				)
          self.assertIsInstance(_snake_case				,       _snake_case				)
          self.assertIsInstance(_snake_case				,       np.ndarray				)

          __lowercase		:			Optional[Any]	    =       retriever(
              _snake_case				,       _snake_case				,       prefix=retriever.config.generator.prefix				,       n_docs=_snake_case				,       return_tensors='''pt'''				,       )
          __lowercase    ,      __lowercase    ,      __lowercase    ,      __lowercase		:			Optional[Any]	    =       (  # noqa: F841
              out['''context_input_ids'''],
              out['''context_attention_mask'''],
              out['''retrieved_doc_embeds'''],
              out['''doc_ids'''],
          )
          self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)				)
          self.assertIsInstance(_snake_case				,       torch.Tensor				)
          self.assertIsInstance(_snake_case				,       torch.Tensor				)
          self.assertIsInstance(_snake_case				,       torch.Tensor				)




      @require_torch
      @require_tokenizers
      @require_sentencepiece
      def 		snake_case_			(      self		:       List[Any]				):
          __lowercase		:			Tuple	    =       self.get_dpr_ctx_encoder_tokenizer()
          __lowercase		:			str	    =       1
          __lowercase		:			int	    =       self.get_dummy_custom_hf_index_retriever(from_disk=_snake_case				)
          retriever.set_ctx_encoder_tokenizer(_snake_case				)

          __lowercase		:			Tuple	    =       [[5, 7], [10, 11]]
          __lowercase		:			int	    =       np.array(
              [np.ones(self.retrieval_vector_size				), -np.ones(self.retrieval_vector_size				)]				,       dtype=np.floataa				)
          __lowercase		:			Any	    =       retriever(_snake_case				,       _snake_case				,       prefix=retriever.config.generator.prefix				,       n_docs=_snake_case				)

          self.assertEqual(
              len(_snake_case				)				,       6				)  # check whether the retriever output consist of 6 attributes including tokenized docs
          self.assertEqual(
              all(k in out for k in ('''tokenized_doc_ids''', '''tokenized_doc_attention_mask''')				)				,       _snake_case				)  # check for doc token related keys in dictionary.


