




"""simple docstring"""




import warnings
from typing import List, Optional, Tuple, Union

import numpy as np
import PIL
import torch

from ...models import UNetaDModel
from ...schedulers import RePaintScheduler
from ...utils import PIL_INTERPOLATION, logging, randn_tensor
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput


lowerCAmelCase				:     Tuple					=				logging.get_logger(__name__)  # pylint: disable=invalid-name



def        a__					(							snake_case__							)		->   int:
			warnings.warn(
			    """The preprocess method is deprecated and will be removed in a future version. Please"""
			    """ use VaeImageProcessor.preprocess instead"""			,					snake_case__			,					)
			if isinstance(snake_case__			,					torch.Tensor							):
						return image
			elif isinstance(snake_case__			,					PIL.Image.Image							):
						lowerCamelCase      =   [image]

			if isinstance(image[0]			,					PIL.Image.Image							):
						lowerCamelCase ,  lowerCamelCase      =   image[0].size
						lowerCamelCase ,  lowerCamelCase      =   (x - x % 8 for x in (w, h))  # resize to integer multiple of 8

						lowerCamelCase      =   [np.array(i.resize((w, h)			,					resample=PIL_INTERPOLATION["""lanczos"""]							)							)[None, :] for i in image]
						lowerCamelCase      =   np.concatenate(snake_case__			,					axis=0							)
						lowerCamelCase      =   np.array(snake_case__							).astype(np.floataa							) / 255.0
						lowerCamelCase      =   image.transpose(0			,					3			,					1			,					2							)
						lowerCamelCase      =   2.0 * image - 1.0
						lowerCamelCase      =   torch.from_numpy(snake_case__							)
			elif isinstance(image[0]			,					torch.Tensor							):
						lowerCamelCase      =   torch.cat(snake_case__			,					dim=0							)
			return image



def        a__					(							snake_case__							)		->   str:
			if isinstance(snake_case__			,					torch.Tensor							):
						return mask
			elif isinstance(snake_case__			,					PIL.Image.Image							):
						lowerCamelCase      =   [mask]

			if isinstance(mask[0]			,					PIL.Image.Image							):
						lowerCamelCase ,  lowerCamelCase      =   mask[0].size
						lowerCamelCase ,  lowerCamelCase      =   (x - x % 32 for x in (w, h))  # resize to integer multiple of 32
						lowerCamelCase      =   [np.array(m.convert("""L"""							).resize((w, h)			,					resample=PIL_INTERPOLATION["""nearest"""]							)							)[None, :] for m in mask]
						lowerCamelCase      =   np.concatenate(snake_case__			,					axis=0							)
						lowerCamelCase      =   mask.astype(np.floataa							) / 255.0
						lowerCamelCase      =   0
						lowerCamelCase      =   1
						lowerCamelCase      =   torch.from_numpy(snake_case__							)
			elif isinstance(mask[0]			,					torch.Tensor							):
						lowerCamelCase      =   torch.cat(snake_case__			,					dim=0							)
			return mask






class        __magic_name__				(			UpperCAmelCase__							):






				'''simple docstring'''
				__UpperCamelCase         =		42
				__UpperCamelCase         =		42





				def __init__(			self						,					_a						,					_a					):





							"""simple docstring"""
							super().__init__()
							self.register_modules(unet=_a						,					scheduler=_a					)





				@torch.no_grad()
				def __call__(			self						,					_a						,					_a						,					_a = 250						,					_a = 0.0						,					_a = 10						,					_a = 10						,					_a = None						,					_a = "pil"						,					_a = True						,					):





							"""simple docstring"""
							lowerCamelCase      =   image

							lowerCamelCase      =   _preprocess_image(_a					)
							lowerCamelCase      =   original_image.to(device=self.device						,					dtype=self.unet.dtype					)
							lowerCamelCase      =   _preprocess_mask(_a					)
							lowerCamelCase      =   mask_image.to(device=self.device						,					dtype=self.unet.dtype					)

							lowerCamelCase      =   original_image.shape[0]

							# sample gaussian noise to begin the loop
							if isinstance(_a						,					_a					) and len(_a					) != batch_size:
										raise ValueError(
										    f'You have passed a list of generators of length {len(_a					)}, but requested an effective batch'
										    f' size of {batch_size}. Make sure the batch size matches the length of the generators.'					)

							lowerCamelCase      =   original_image.shape
							lowerCamelCase      =   randn_tensor(_a						,					generator=_a						,					device=self.device						,					dtype=self.unet.dtype					)

							# set step values
							self.scheduler.set_timesteps(_a						,					_a						,					_a						,					self.device					)
							lowerCamelCase      =   eta

							lowerCamelCase      =   self.scheduler.timesteps[0] + 1
							lowerCamelCase      =   generator[0] if isinstance(_a						,					_a					) else generator
							for i, t in enumerate(self.progress_bar(self.scheduler.timesteps					)					):
										if t < t_last:
													# predict the noise residual
													lowerCamelCase      =   self.unet(_a						,					_a					).sample
													# compute previous image: x_t -> x_t-1
													lowerCamelCase      =   self.scheduler.step(_a						,					_a						,					_a						,					_a						,					_a						,					_a					).prev_sample

										else:
													# compute the reverse: x_t-1 -> x_t
													lowerCamelCase      =   self.scheduler.undo_step(_a						,					_a						,					_a					)
										lowerCamelCase      =   t

							lowerCamelCase      =   (image / 2 + 0.5).clamp(0						,					1					)
							lowerCamelCase      =   image.cpu().permute(0						,					2						,					3						,					1					).numpy()
							if output_type == "pil":
										lowerCamelCase      =   self.numpy_to_pil(_a					)

							if not return_dict:
										return (image,)

							return ImagePipelineOutput(images=_a					)









"""simple docstring"""




import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    FalconForCausalLM,
					    FalconForQuestionAnswering,
					    FalconForSequenceClassification,
					    FalconForTokenClassification,
					    FalconModel,
					)






class        __magic_name__				:






				'''simple docstring'''





				def __init__(			self						,					_a						,					_a=3						,					_a=7						,					_a=True						,					_a=True						,					_a=False						,					_a=True						,					_a=99						,					_a=32						,					_a=5						,					_a=4						,					_a=37						,					_a="gelu"						,					_a=0.1						,					_a=0.1						,					_a=512						,					_a=16						,					_a=2						,					_a=0.02						,					_a=3						,					_a=4						,					_a=None						,					):





							"""simple docstring"""
							lowerCamelCase      =   parent
							lowerCamelCase      =   batch_size
							lowerCamelCase      =   seq_length
							lowerCamelCase      =   is_training
							lowerCamelCase      =   use_input_mask
							lowerCamelCase      =   use_token_type_ids
							lowerCamelCase      =   use_labels
							lowerCamelCase      =   vocab_size
							lowerCamelCase      =   hidden_size
							lowerCamelCase      =   num_hidden_layers
							lowerCamelCase      =   num_attention_heads
							lowerCamelCase      =   intermediate_size
							lowerCamelCase      =   hidden_act
							lowerCamelCase      =   hidden_dropout_prob
							lowerCamelCase      =   attention_probs_dropout_prob
							lowerCamelCase      =   max_position_embeddings
							lowerCamelCase      =   type_vocab_size
							lowerCamelCase      =   type_sequence_label_size
							lowerCamelCase      =   initializer_range
							lowerCamelCase      =   num_labels
							lowerCamelCase      =   num_choices
							lowerCamelCase      =   scope





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   ids_tensor([self.batch_size, self.seq_length]						,					self.vocab_size					)

							lowerCamelCase      =   None
							if self.use_input_mask:
										lowerCamelCase      =   random_attention_mask([self.batch_size, self.seq_length]					)

							lowerCamelCase      =   None

							lowerCamelCase      =   None
							lowerCamelCase      =   None
							lowerCamelCase      =   None
							if self.use_labels:
										lowerCamelCase      =   ids_tensor([self.batch_size]						,					self.type_sequence_label_size					)
										lowerCamelCase      =   ids_tensor([self.batch_size, self.seq_length]						,					self.num_labels					)
										lowerCamelCase      =   ids_tensor([self.batch_size]						,					self.num_choices					)

							lowerCamelCase      =   self.get_config()

							return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							return FalconConfig(
							    vocab_size=self.vocab_size						,					hidden_size=self.hidden_size						,					num_hidden_layers=self.num_hidden_layers						,					num_attention_heads=self.num_attention_heads						,					intermediate_size=self.intermediate_size						,					hidden_act=self.hidden_act						,					hidden_dropout_prob=self.hidden_dropout_prob						,					attention_probs_dropout_prob=self.attention_probs_dropout_prob						,					max_position_embeddings=self.max_position_embeddings						,					type_vocab_size=self.type_vocab_size						,					is_decoder=_a						,					initializer_range=self.initializer_range						,					pad_token_id=1						,					new_decoder_architecture=_a						,					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a					):





							"""simple docstring"""
							lowerCamelCase      =   FalconModel(config=_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a					)
							lowerCamelCase      =   model(_a					)
							self.parent.assertEqual(result.last_hidden_state.shape						,					(self.batch_size, self.seq_length, self.hidden_size)					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					):





							"""simple docstring"""
							lowerCamelCase      =   True
							lowerCamelCase      =   FalconModel(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					encoder_attention_mask=_a						,					)
							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					)
							lowerCamelCase      =   model(_a						,					attention_mask=_a					)
							self.parent.assertEqual(result.last_hidden_state.shape						,					(self.batch_size, self.seq_length, self.hidden_size)					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					):





							"""simple docstring"""
							lowerCamelCase      =   FalconForCausalLM(config=_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a						,					labels=_a					)
							self.parent.assertEqual(result.logits.shape						,					(self.batch_size, self.seq_length, self.vocab_size)					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					):





							"""simple docstring"""
							lowerCamelCase      =   True
							lowerCamelCase      =   True
							lowerCamelCase      =   FalconForCausalLM(config=_a					)
							model.to(_a					)
							model.eval()

							# first forward pass
							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					encoder_attention_mask=_a						,					use_cache=_a						,					)
							lowerCamelCase      =   outputs.past_key_values

							# create hypothetical multiple next token and extent to next_input_ids
							lowerCamelCase      =   ids_tensor((self.batch_size, 3)						,					config.vocab_size					)
							lowerCamelCase      =   ids_tensor((self.batch_size, 3)						,					vocab_size=2					)

							# append to next input_ids and
							lowerCamelCase      =   torch.cat([input_ids, next_tokens]						,					dim=-1					)
							lowerCamelCase      =   torch.cat([input_mask, next_mask]						,					dim=-1					)

							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					encoder_attention_mask=_a						,					output_hidden_states=_a						,					)["""hidden_states"""][0]
							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					encoder_attention_mask=_a						,					past_key_values=_a						,					output_hidden_states=_a						,					)["""hidden_states"""][0]

							# select random slice
							lowerCamelCase      =   ids_tensor((1,)						,					output_from_past.shape[-1]					).item()
							lowerCamelCase      =   output_from_no_past[:, -3:, random_slice_idx].detach()
							lowerCamelCase      =   output_from_past[:, :, random_slice_idx].detach()

							self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]					)

							# test that outputs are equal for slice
							self.parent.assertTrue(torch.allclose(_a						,					_a						,					atol=1e-3					)					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.prepare_config_and_inputs()
							(
							    (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  
							)      =   config_and_inputs
							lowerCamelCase      =   {"""input_ids""": input_ids, """attention_mask""": input_mask}
							return config, inputs_dict






@require_torch
class        __magic_name__				(			UpperCAmelCase__		,   UpperCAmelCase__		,   UpperCAmelCase__		,   unittest.TestCase							):






				'''simple docstring'''
				__UpperCamelCase         =		(
				    (
				        FalconModel,
				        FalconForCausalLM,
				        FalconForSequenceClassification,
				        FalconForTokenClassification,
				        FalconForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				__UpperCamelCase         =		(FalconForCausalLM,) if is_torch_available() else ()
				__UpperCamelCase         =		(
				    {
				        "feature-extraction": FalconModel,
				        "text-classification": FalconForSequenceClassification,
				        "text-generation": FalconForCausalLM,
				        "question-answering": FalconForQuestionAnswering,
				        "token-classification": FalconForTokenClassification,
				        "zero-shot": FalconForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				__UpperCamelCase         =		False
				__UpperCamelCase         =		False





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   FalconModelTester(self					)
							lowerCamelCase      =   ConfigTester(self						,					config_class=_a						,					hidden_size=37					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							self.config_tester.run_common_tests()





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_a					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  *lowerCamelCase      =   self.model_tester.prepare_config_and_inputs()
							for alibi in [True, False]:
										lowerCamelCase      =   alibi
										self.model_tester.create_and_check_model(_a						,					*_a					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase      =   3
							lowerCamelCase      =   input_dict["""input_ids"""]
							lowerCamelCase      =   input_ids.ne(1					).to(_a					)
							lowerCamelCase      =   ids_tensor([self.model_tester.batch_size]						,					self.model_tester.type_sequence_label_size					)
							lowerCamelCase      =   FalconForSequenceClassification(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a						,					labels=_a					)
							self.assertEqual(result.logits.shape						,					(self.model_tester.batch_size, self.model_tester.num_labels)					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase      =   3
							lowerCamelCase      =   """single_label_classification"""
							lowerCamelCase      =   input_dict["""input_ids"""]
							lowerCamelCase      =   input_ids.ne(1					).to(_a					)
							lowerCamelCase      =   ids_tensor([self.model_tester.batch_size]						,					self.model_tester.type_sequence_label_size					)
							lowerCamelCase      =   FalconForSequenceClassification(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a						,					labels=_a					)
							self.assertEqual(result.logits.shape						,					(self.model_tester.batch_size, self.model_tester.num_labels)					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase      =   input_dict["""input_ids"""]
							lowerCamelCase      =   FalconForCausalLM(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					use_cache=_a					)
							lowerCamelCase      =   input_ids.shape[0]
							lowerCamelCase      =   model._convert_to_rw_cache(result.past_key_values					)
							lowerCamelCase      =   model._convert_cache_to_standard_format(_a						,					_a					)
							for layer in range(len(_a					)					):
										for tensor_idx in range(2					):
													self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3					)
													self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4					)
													self.assertTrue(
													    torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]					)					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase      =   3
							lowerCamelCase      =   """multi_label_classification"""
							lowerCamelCase      =   input_dict["""input_ids"""]
							lowerCamelCase      =   input_ids.ne(1					).to(_a					)
							lowerCamelCase      =   ids_tensor(
							    [self.model_tester.batch_size, config.num_labels]						,					self.model_tester.type_sequence_label_size					).to(torch.float					)
							lowerCamelCase      =   FalconForSequenceClassification(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a						,					labels=_a					)
							self.assertEqual(result.logits.shape						,					(self.model_tester.batch_size, self.model_tester.num_labels)					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# Falcon can have different numbers of KV-heads than the number of query heads, so we need
							# to override this test to use the right head counts.
							for model_class in self.all_generative_model_classes:
										lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()

										# If it doesn't support cache, pass the test
										if not hasattr(_a						,					"""use_cache"""					):
													return

										lowerCamelCase      =   model_class(_a					).to(_a					)
										if "use_cache" not in inputs:
													lowerCamelCase      =   True
										lowerCamelCase      =   model(**_a					)

										# If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
										if "past_key_values" not in outputs:
													return

										lowerCamelCase      =   (
										    getattr(_a						,					"""decoder_layers"""						,					_a					)
										    or getattr(_a						,					"""num_decoder_layers"""						,					_a					)
										    or config.num_hidden_layers
										)
										lowerCamelCase      =   getattr(_a						,					"""num_kv_heads"""						,					config.num_attention_heads					)
										lowerCamelCase      =   getattr(_a						,					"""d_model"""						,					config.hidden_size					)
										lowerCamelCase      =   embed_dim // num_attention_heads

										lowerCamelCase      =   outputs["""past_key_values"""]
										self.assertEqual(len(_a					)						,					_a					)

										lowerCamelCase ,  lowerCamelCase      =   inputs["""input_ids"""].shape
										for i in range(_a					):
													if config.new_decoder_architecture:
																lowerCamelCase      =   config.num_attention_heads
													elif config.multi_query:
																lowerCamelCase      =   1
													self.assertEqual(len(past_kv[0]					)						,					2					)  # K V for the decoder = 2
													self.assertEqual(
													    past_kv[i][0].shape						,					(batch_size, num_attention_heads, seq_length, per_head_embed_dim)					)
													self.assertEqual(
													    past_kv[i][1].shape						,					(batch_size, num_attention_heads, seq_length, per_head_embed_dim)					)






@require_torch
class        __magic_name__				(			unittest.TestCase							):






				'''simple docstring'''





				@slow
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   AutoTokenizer.from_pretrained("""Rocketknight1/falcon-rw-1b"""					)
							lowerCamelCase      =   FalconForCausalLM.from_pretrained("""Rocketknight1/falcon-rw-1b"""					)
							model.eval()
							model.to(_a					)
							lowerCamelCase      =   tokenizer("""My favorite food is"""						,					return_tensors="""pt"""					).to(_a					)

							lowerCamelCase      =   (
							    """My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday."""
							)

							lowerCamelCase      =   model.generate(**_a						,					do_sample=_a						,					max_new_tokens=19					)
							lowerCamelCase      =   tokenizer.batch_decode(_a					)[0]

							self.assertEqual(_a						,					_a					)





				@slow
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# The big models are way too big for the CI, so we use tiny random models that resemble their
							# architectures but with much smaller and fewer layers
							for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
										lowerCamelCase      =   AutoTokenizer.from_pretrained(_a					)
										lowerCamelCase      =   FalconForCausalLM.from_pretrained(_a					)
										model.eval()
										model.to(_a					)
										lowerCamelCase      =   tokenizer("""My favorite food is"""						,					return_tensors="""pt"""					).to(_a					)

										# We just test that these run without errors - the models are randomly initialized
										# and so the actual text outputs will be garbage
										model.generate(**_a						,					do_sample=_a						,					max_new_tokens=4					)
										model.generate(**_a						,					do_sample=_a						,					max_new_tokens=4					)
										model.generate(**_a						,					num_beams=2						,					max_new_tokens=4					)





				@slow
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# The big models are way too big for the CI, so we use tiny random models that resemble their
							# architectures but with much smaller and fewer layers
							with torch.no_grad():
										for repo in [
										    "Rocketknight1/falcon-rw-1b",
										    "Rocketknight1/tiny-random-falcon-7b",
										    "Rocketknight1/tiny-random-falcon-40b",
										]:
													lowerCamelCase      =   AutoTokenizer.from_pretrained(_a					)
													lowerCamelCase      =   FalconForCausalLM.from_pretrained(_a					)
													model.eval()
													model.to(device=_a					)
													lowerCamelCase      =   tokenizer("""My favorite food is"""						,					return_tensors="""pt"""					).to(_a					)

													# Test results are the same with and without cache
													lowerCamelCase      =   model.generate(**_a						,					do_sample=_a						,					max_new_tokens=20						,					use_cache=_a					)
													lowerCamelCase      =   model.generate(**_a						,					do_sample=_a						,					max_new_tokens=20						,					use_cache=_a					)
													self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0					)



