




'''simple docstring'''
import os
from typing import Optional, Union

import numpy as np
from huggingface_hub import hf_hub_download

from ... import AutoTokenizer
from ...utils import logging


A				: Optional[int]					      =			"""block_records.npy"""


A				: str					      =			logging.get_logger(__name__)
def 							snake_case_    (  a__						:      str       ,a__						:      int     ):



    """simple docstring"""




    import tensorflow.compat.va as tf

    __lowercase     							=		tf.data.TFRecordDataset(UpperCamelCase__       ,buffer_size=5_12 * 10_24 * 10_24     )
    __lowercase     							=		blocks_dataset.batch(UpperCamelCase__       ,drop_remainder=UpperCamelCase__     )
    __lowercase     							=		next(blocks_dataset.take(1     ).as_numpy_iterator()     )

    return np_record






class 			SCREAMING_SNAKE_CASE:

       def __init__(       self   ,						lowerCamelCase__   ,						lowerCamelCase__   ,						lowerCamelCase__=2   ,						lowerCamelCase__=1000   ,						lowerCamelCase__=100   ,						lowerCamelCase__=10_0000   ,						)       ->   Optional[int]:

           """simple docstring"""



           from scann.scann_ops.py.scann_ops_pybind import builder as Builder

           __lowercase     							=		Builder(db=__UpperCAmelCase   ,						num_neighbors=__UpperCAmelCase   ,						distance_measure="""dot_product"""	)
           __lowercase     							=		builder.tree(
               num_leaves=__UpperCAmelCase   ,						num_leaves_to_search=__UpperCAmelCase   ,						training_sample_size=__UpperCAmelCase	)
           __lowercase     							=		builder.score_ah(dimensions_per_block=__UpperCAmelCase	)

           __lowercase     							=		builder.build()




       def        snake_case__     (       self   ,						lowerCamelCase__	)       ->   Tuple:

           """simple docstring"""



           __lowercase							,__lowercase     							=		self.searcher.search_batched(question_projection.detach().cpu()	)
           return retrieved_block_ids.astype("""int64"""	)






class 			SCREAMING_SNAKE_CASE:

       def __init__(       self   ,						lowerCamelCase__   ,						lowerCamelCase__	)       ->   List[str]:

           """simple docstring"""



           super().__init__()
           __lowercase     							=		block_records
           __lowercase     							=		tokenizer

       def __call__(       self   ,						lowerCamelCase__   ,						lowerCamelCase__   ,						lowerCamelCase__   ,						lowerCamelCase__=None   ,						lowerCamelCase__="pt"	)       ->   str:

           """simple docstring"""



           __lowercase     							=		np.take(self.block_records   ,						indices=__UpperCAmelCase   ,						axis=0	)

           __lowercase     							=		self.tokenizer.decode(question_input_ids[0]   ,						skip_special_tokens=__UpperCAmelCase	)

           __lowercase     							=		[]
           __lowercase     							=		[]
           for retrieved_block in retrieved_blocks:
               text.append(__UpperCAmelCase	)
               text_pair.append(retrieved_block.decode()	)

           __lowercase     							=		self.tokenizer(
               __UpperCAmelCase   ,						__UpperCAmelCase   ,						padding=__UpperCAmelCase   ,						truncation=__UpperCAmelCase   ,						return_special_tokens_mask=__UpperCAmelCase   ,						max_length=__UpperCAmelCase	)
           __lowercase     							=		concat_inputs.convert_to_tensors(__UpperCAmelCase	)

           if answer_ids is not None:
               return self.block_has_answer(__UpperCAmelCase   ,						__UpperCAmelCase	) + (concat_inputs_tensors,)
           else:
               return (None, None, None, concat_inputs_tensors)

       @classmethod
       def        snake_case__     (       cls   ,						lowerCamelCase__   ,						*lowerCamelCase__   ,						**lowerCamelCase__	)       ->   List[Any]:

           """simple docstring"""



           if os.path.isdir(__UpperCAmelCase	):
               __lowercase     							=		os.path.join(__UpperCAmelCase   ,						_REALM_BLOCK_RECORDS_FILENAME	)
           else:
               __lowercase     							=		hf_hub_download(
                   repo_id=__UpperCAmelCase   ,						filename=_REALM_BLOCK_RECORDS_FILENAME   ,						**__UpperCAmelCase	)
           __lowercase     							=		np.load(__UpperCAmelCase   ,						allow_pickle=__UpperCAmelCase	)

           __lowercase     							=		AutoTokenizer.from_pretrained(__UpperCAmelCase   ,						*__UpperCAmelCase   ,						**__UpperCAmelCase	)

           return cls(__UpperCAmelCase   ,						__UpperCAmelCase	)

       def        snake_case__     (       self   ,						lowerCamelCase__	)       ->   Tuple:

           """simple docstring"""



           np.save(os.path.join(__UpperCAmelCase   ,						_REALM_BLOCK_RECORDS_FILENAME	)   ,						self.block_records	)
           # save tokenizer
           self.tokenizer.save_pretrained(__UpperCAmelCase	)




       def        snake_case__     (       self   ,						lowerCamelCase__   ,						lowerCamelCase__	)       ->   List[Any]:

           """simple docstring"""



           __lowercase     							=		[]
           __lowercase     							=		[]
           __lowercase     							=		[]
           __lowercase     							=		0

           for input_id in concat_inputs.input_ids:
               __lowercase     							=		input_id.tolist()
               # Check answers between two [SEP] tokens
               __lowercase     							=		input_id_list.index(self.tokenizer.sep_token_id	)
               __lowercase     							=		first_sep_idx + 1 + input_id_list[first_sep_idx + 1 :].index(self.tokenizer.sep_token_id	)

               start_pos.append([]	)
               end_pos.append([]	)
               for answer in answer_ids:
                   for idx in range(first_sep_idx + 1   ,						__UpperCAmelCase	):
                       if answer[0] == input_id_list[idx]:
                           if input_id_list[idx : idx + len(__UpperCAmelCase	)] == answer:
                               start_pos[-1].append(__UpperCAmelCase	)
                               end_pos[-1].append(idx + len(__UpperCAmelCase	) - 1	)

               if len(start_pos[-1]	) == 0:
                   has_answers.append(__UpperCAmelCase	)
               else:
                   has_answers.append(__UpperCAmelCase	)
                   if len(start_pos[-1]	) > max_answers:
                       __lowercase     							=		len(start_pos[-1]	)

        # Pad -1 to max_answers
           for start_pos_, end_pos_ in zip(__UpperCAmelCase   ,						__UpperCAmelCase	):
               if len(start_pos_	) < max_answers:
                   __lowercase     							=		[-1] * (max_answers - len(start_pos_	))
                   start_pos_ += padded
                   end_pos_ += padded
           return has_answers, start_pos, end_pos





"""simple docstring"""




from dataclasses import dataclass
from typing import Optional, Tuple, Union

import flax
import jax.numpy as jnp
from scipy import integrate

from ..configuration_utils import ConfigMixin, register_to_config
from .scheduling_utils_flax import (
    CommonSchedulerState,
    FlaxKarrasDiffusionSchedulers,
    FlaxSchedulerMixin,
    FlaxSchedulerOutput,
    broadcast_to_shape_from_left,
)
@flax.struct.dataclass
class      UpperCamelCase__:
						lowerCAmelCase__	:    CommonSchedulerState

						# setable values
						lowerCAmelCase__	:    jnp.ndarray
						lowerCAmelCase__	:    jnp.ndarray
						lowerCAmelCase__	:    jnp.ndarray
						lowerCAmelCase__	:    Optional[int]    				=		None

						# running values
						lowerCAmelCase__	:    Optional[jnp.ndarray]    				=		None





						@classmethod
						def 					snake_case__						(							cls		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  )       ->					Optional[Any]:
													return cls(common=__UpperCAmelCase		,init_noise_sigma=__UpperCAmelCase		,timesteps=__UpperCAmelCase		,sigmas=__UpperCAmelCase  )






@dataclass
class      UpperCamelCase__(      __A			):
						lowerCAmelCase__	:    LMSDiscreteSchedulerState






class      UpperCamelCase__(      __A		,    __A			):
						lowerCAmelCase__	:    List[str]    				=		[e.name for e in FlaxKarrasDiffusionSchedulers]

						lowerCAmelCase__	:    jnp.dtype





						@property
						def 					snake_case__						(							self  )       ->					Union[str, Any]:
													return True





						@register_to_config
						def __init__(							self		,__UpperCAmelCase = 10_00		,__UpperCAmelCase = 0.0_0_0_1		,__UpperCAmelCase = 0.0_2		,__UpperCAmelCase = "linear"		,__UpperCAmelCase = None		,__UpperCAmelCase = "epsilon"		,__UpperCAmelCase = jnp.floataa		,)       ->					str:
													A__						  =				dtype





						def 					snake_case__						(							self		,__UpperCAmelCase = None  )       ->					LMSDiscreteSchedulerState:
													if common is None:
																				A__						  =				CommonSchedulerState.create(self  )

													A__						  =				jnp.arange(0		,self.config.num_train_timesteps  ).round()[::-1]
													A__						  =				((1 - common.alphas_cumprod) / common.alphas_cumprod) ** 0.5

													# standard deviation of the initial noise distribution
													A__						  =				sigmas.max()

													return LMSDiscreteSchedulerState.create(
													    common=__UpperCAmelCase		,init_noise_sigma=__UpperCAmelCase		,timesteps=__UpperCAmelCase		,sigmas=__UpperCAmelCase		,)





						def 					snake_case__						(							self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  )       ->					jnp.ndarray:
													((A__)  ,	)						  =				jnp.where(state.timesteps == timestep		,size=1  )
													A__						  =				step_index[0]

													A__						  =				state.sigmas[step_index]
													A__						  =				sample / ((sigma**2 + 1) ** 0.5)
													return sample





						def 					snake_case__						(							self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  )       ->					Optional[int]:

													def lms_derivative(__UpperCAmelCase  ):
																				A__						  =				1.0
																				for k in range(__UpperCAmelCase  ):
																											if current_order == k:
																																		continue
																											prod *= (tau - state.sigmas[t - k]) / (state.sigmas[t - current_order] - state.sigmas[t - k])
																				return prod

													A__						  =				integrate.quad(__UpperCAmelCase		,state.sigmas[t]		,state.sigmas[t + 1]		,epsrel=1e-4  )[0]

													return integrated_coeff





						def 					snake_case__						(							self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase = ()  )       ->					LMSDiscreteSchedulerState:
													A__						  =				jnp.linspace(self.config.num_train_timesteps - 1		,0		,__UpperCAmelCase		,dtype=self.dtype  )

													A__						  =				jnp.floor(__UpperCAmelCase  ).astype(jnp.intaa  )
													A__						  =				jnp.ceil(__UpperCAmelCase  ).astype(jnp.intaa  )

													A__						  =				jnp.mod(__UpperCAmelCase		,1.0  )

													A__						  =				((1 - state.common.alphas_cumprod) / state.common.alphas_cumprod) ** 0.5
													A__						  =				(1 - frac) * sigmas[low_idx] + frac * sigmas[high_idx]
													A__						  =				jnp.concatenate([sigmas, jnp.array([0.0]		,dtype=self.dtype  )]  )

													A__						  =				timesteps.astype(jnp.intaa  )

													# initial running values
													A__						  =				jnp.zeros((0,) + shape		,dtype=self.dtype  )

													return state.replace(
													    timesteps=__UpperCAmelCase		,sigmas=__UpperCAmelCase		,num_inference_steps=__UpperCAmelCase		,derivatives=__UpperCAmelCase		,)





						def 					snake_case__						(							self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase = 4		,__UpperCAmelCase = True		,)       ->					Union[FlaxLMSSchedulerOutput, Tuple]:
													if state.num_inference_steps is None:
																				raise ValueError(
																				    'Number of inference steps is \'None\', you need to run \'set_timesteps\' after creating the scheduler'  )

													A__						  =				state.sigmas[timestep]

													# 1. compute predicted original sample (x_0) from sigma-scaled predicted noise
													if self.config.prediction_type == "epsilon":
																				A__						  =				sample - sigma * model_output
													elif self.config.prediction_type == "v_prediction":
																				# * c_out + input * c_skip
																				A__						  =				model_output * (-sigma / (sigma**2 + 1) ** 0.5) + (sample / (sigma**2 + 1))
													else:
																				raise ValueError(
																				    f'''prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`'''  )

													# 2. Convert to an ODE derivative
													A__						  =				(sample - pred_original_sample) / sigma
													A__						  =				state.replace(derivatives=jnp.append(state.derivatives		,__UpperCAmelCase  )  )
													if len(state.derivatives  ) > order:
																				A__						  =				state.replace(derivatives=jnp.delete(state.derivatives		,0  )  )

													# 3. Compute linear multistep coefficients
													A__						  =				min(timestep + 1		,__UpperCAmelCase  )
													A__						  =				[self.get_lms_coefficient(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  ) for curr_order in range(__UpperCAmelCase  )]

													# 4. Compute previous sample based on the derivatives path
													A__						  =				sample + sum(
													    coeff * derivative for coeff, derivative in zip(__UpperCAmelCase		,reversed(state.derivatives  )  )  )

													if not return_dict:
																				return (prev_sample, state)

													return FlaxLMSSchedulerOutput(prev_sample=__UpperCAmelCase		,state=__UpperCAmelCase  )





						def 					snake_case__						(							self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,)       ->					jnp.ndarray:
													A__						  =				state.sigmas[timesteps].flatten()
													A__						  =				broadcast_to_shape_from_left(__UpperCAmelCase		,noise.shape  )

													A__						  =				original_samples + noise * sigma

													return noisy_samples





						def __len__(							self  )       ->					Optional[Any]:
													return self.config.num_train_timesteps





