code: 
  
  
  
  import inspect
  import unittest
  
  import requests
  
  from transformers import MgpstrConfig
  from transformers.testing_utils import require_torch, require_vision, slow, torch_device
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
  	import torch
  	from torch import nn
  
  	from transformers import MgpstrForSceneTextRecognition
  
  
  if is_vision_available():
  	from PIL import Image
  
  	from transformers import MgpstrProcessor
  
  
  
  
  
  
  class 	lowercase		:
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	def __init__(			self			:		int		,						__UpperCAmelCase			:		Any		,						__UpperCAmelCase			:		Optional[int]=False		,						__UpperCAmelCase			:		Union[str, Any]=13		,						__UpperCAmelCase			:		Tuple=(32, 128)		,						__UpperCAmelCase			:		Any=4		,						__UpperCAmelCase			:		Any=3		,						__UpperCAmelCase			:		int=27		,						__UpperCAmelCase			:		Union[str, Any]=38		,						__UpperCAmelCase			:		int=99		,						__UpperCAmelCase			:		str=99		,						__UpperCAmelCase			:		List[str]=32		,						__UpperCAmelCase			:		Optional[Any]=5		,						__UpperCAmelCase			:		int=4		,						__UpperCAmelCase			:		Union[str, Any]=4.0		,						__UpperCAmelCase			:		List[Any]=257		,						__UpperCAmelCase			:		Any=None		,						)    ->				Optional[Any]:
  							UpperCAmelCase_=     parent
  							UpperCAmelCase_=     is_training
  							UpperCAmelCase_=     batch_size
  							UpperCAmelCase_=     image_size
  							UpperCAmelCase_=     patch_size
  							UpperCAmelCase_=     num_channels
  							UpperCAmelCase_=     max_token_length
  							UpperCAmelCase_=     num_character_labels
  							UpperCAmelCase_=     num_bpe_labels
  							UpperCAmelCase_=     num_wordpiece_labels
  							UpperCAmelCase_=     hidden_size
  							UpperCAmelCase_=     num_hidden_layers
  							UpperCAmelCase_=     num_attention_heads
  							UpperCAmelCase_=     mlp_ratio
  							UpperCAmelCase_=     patch_embeds_hidden_size
  							UpperCAmelCase_=     output_hidden_states
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				Any:
  							UpperCAmelCase_=     floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]  )
  							UpperCAmelCase_=     self.get_config()
  							return config, pixel_values
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				List[str]:
  							return MgpstrConfig(
  							    image_size=self.image_size		,						patch_size=self.patch_size		,						num_channels=self.num_channels		,						max_token_length=self.max_token_length		,						num_character_labels=self.num_character_labels		,						num_bpe_labels=self.num_bpe_labels		,						num_wordpiece_labels=self.num_wordpiece_labels		,						hidden_size=self.hidden_size		,						num_hidden_layers=self.num_hidden_layers		,						num_attention_heads=self.num_attention_heads		,						mlp_ratio=self.mlp_ratio		,						output_hidden_states=self.output_hidden_states		,						)
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		int		,						__UpperCAmelCase			:		int		,						__UpperCAmelCase			:		Optional[Any]  )    ->				List[str]:
  							UpperCAmelCase_=     MgpstrForSceneTextRecognition(__UpperCAmelCase  )
  							model.to(__UpperCAmelCase  )
  							model.eval()
  							with torch.no_grad():
  													UpperCAmelCase_=     model(__UpperCAmelCase  )
  							self.parent.assertEqual(
  							    generated_ids[0][0].shape		,						(self.batch_size, self.max_token_length, self.num_character_labels)  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				int:
  							UpperCAmelCase_=     self.prepare_config_and_inputs()
  							UpperCAmelCase_,     UpperCAmelCase_=     config_and_inputs
  							UpperCAmelCase_=     {"""pixel_values""": pixel_values}
  							return config, inputs_dict
  
  
  
  
  
  
  @require_torch
  class 	lowercase		(				snake_case__				,					snake_case__				,					unittest.TestCase):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      Optional[Any]	     =							(MgpstrForSceneTextRecognition,) if is_torch_available() else ()
  	a__   :      Tuple	     =							{"feature-extraction": MgpstrForSceneTextRecognition} if is_torch_available() else {}
  	a__   :      Optional[Any]	     =							False
  
  	a__   :      int	     =							False
  	a__   :      int	     =							False
  	a__   :      Union[str, Any]	     =							False
  	a__   :      Tuple	     =							False
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				int:
  							UpperCAmelCase_=     MgpstrModelTester(self  )
  							UpperCAmelCase_=     ConfigTester(self		,						config_class=__UpperCAmelCase		,						has_text_modality=__UpperCAmelCase  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				Optional[int]:
  							self.config_tester.run_common_tests()
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Tuple  )    ->				int:
  							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
  							self.model_tester.create_and_check_model(*__UpperCAmelCase  )
  
  
  
  
  	@unittest.skip(reason="""MgpstrModel does not use inputs_embeds"""  )
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Tuple  )    ->				Optional[int]:
  							pass
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				Tuple:
  							UpperCAmelCase_,     UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs_for_common()
  
  							for model_class in self.all_model_classes:
  													UpperCAmelCase_=     model_class(__UpperCAmelCase  )
  													self.assertIsInstance(model.get_input_embeddings()		,						(nn.Module)  )
  													UpperCAmelCase_=     model.get_output_embeddings()
  													self.assertTrue(x is None or isinstance(__UpperCAmelCase		,						nn.Linear  )  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Any  )    ->				Optional[Any]:
  							UpperCAmelCase_,     UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs_for_common()
  
  							for model_class in self.all_model_classes:
  													UpperCAmelCase_=     model_class(__UpperCAmelCase  )
  													UpperCAmelCase_=     inspect.signature(model.forward  )
  													# signature.parameters is an OrderedDict => so arg_names order is deterministic
  													UpperCAmelCase_=     [*signature.parameters.keys()]
  
  													UpperCAmelCase_=     ["""pixel_values"""]
  													self.assertListEqual(arg_names[:1]		,						__UpperCAmelCase  )
  
  
  
  
  	@unittest.skip(reason="""MgpstrModel does not support feedforward chunking"""  )
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Any:
  							pass
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				Any:
  							UpperCAmelCase_,     UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs_for_common()
  
  							for model_class in self.all_model_classes:
  													if not model_class.supports_gradient_checkpointing:
  																			continue
  
  													UpperCAmelCase_=     True
  													UpperCAmelCase_=     model_class(__UpperCAmelCase  )
  													self.assertTrue(model.is_gradient_checkpointing  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		int  )    ->				List[Any]:
  							def check_hidden_states_output(__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		Optional[Any]  ):
  													UpperCAmelCase_=     model_class(__UpperCAmelCase  )
  													model.to(__UpperCAmelCase  )
  													model.eval()
  
  													with torch.no_grad():
  																			UpperCAmelCase_=     model(**self._prepare_for_class(__UpperCAmelCase		,						__UpperCAmelCase  )  )
  
  													UpperCAmelCase_=     outputs.hidden_states
  
  													UpperCAmelCase_=     getattr(
  													    self.model_tester		,						"""expected_num_hidden_layers"""		,						self.model_tester.num_hidden_layers + 1  )
  													self.assertEqual(len(__UpperCAmelCase  )		,						__UpperCAmelCase  )
  
  													self.assertListEqual(
  													    list(hidden_states[0].shape[-2:]  )		,						[self.model_tester.patch_embeds_hidden_size, self.model_tester.hidden_size]		,						)
  
  							UpperCAmelCase_,     UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs_for_common()
  
  							for model_class in self.all_model_classes:
  													UpperCAmelCase_=     True
  													check_hidden_states_output(__UpperCAmelCase		,						__UpperCAmelCase		,						__UpperCAmelCase  )
  
  													# check that output_hidden_states also work using config
  													del inputs_dict["output_hidden_states"]
  													UpperCAmelCase_=     True
  
  													check_hidden_states_output(__UpperCAmelCase		,						__UpperCAmelCase		,						__UpperCAmelCase  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[str]  )    ->				Optional[Any]:
  							UpperCAmelCase_,     UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs_for_common()
  
  							UpperCAmelCase_=     _config_zero_init(__UpperCAmelCase  )
  							for model_class in self.all_model_classes:
  													UpperCAmelCase_=     model_class(config=__UpperCAmelCase  )
  													for name, param in model.named_parameters():
  																			if isinstance(__UpperCAmelCase		,						(nn.Linear, nn.Convad, nn.LayerNorm)  ):
  																									if param.requires_grad:
  																															self.assertIn(
  																															    ((param.data.mean() * 1E9).round() / 1E9).item()		,						[0.0, 1.0]		,						msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""		,						)
  
  
  
  
  	@unittest.skip(reason="""Retain_grad is tested in individual model tests"""  )
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		int  )    ->				str:
  							pass
  
  
  
  def  __a  (					)   ->				int:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCAmelCase_=     """https://i.postimg.cc/ZKwLg2Gw/367-14.png"""
  						UpperCAmelCase_=     Image.open(requests.get(lowerCAmelCase_    ,stream=lowerCAmelCase_       ).raw       ).convert("""RGB"""       )
  						return im
  
  
  
  
  
  
  @require_vision
  @require_torch
  class 	lowercase		(				unittest.TestCase):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	@slow
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Any  )    ->				Optional[Any]:
  							UpperCAmelCase_=     """alibaba-damo/mgp-str-base"""
  							UpperCAmelCase_=     MgpstrForSceneTextRecognition.from_pretrained(__UpperCAmelCase  ).to(__UpperCAmelCase  )
  							UpperCAmelCase_=     MgpstrProcessor.from_pretrained(__UpperCAmelCase  )
  
  							UpperCAmelCase_=     prepare_img()
  							UpperCAmelCase_=     processor(images=__UpperCAmelCase		,						return_tensors="""pt"""  ).pixel_values.to(__UpperCAmelCase  )
  
  							# forward pass
  							with torch.no_grad():
  													UpperCAmelCase_=     model(__UpperCAmelCase  )
  
  							# verify the logits
  							self.assertEqual(outputs.logits[0].shape		,						torch.Size((1, 27, 38)  )  )
  
  							UpperCAmelCase_=     processor.batch_decode(outputs.logits  )
  							UpperCAmelCase_=     """ticket"""
  
  							self.assertEqual(out_strs["""generated_text"""][0]		,						__UpperCAmelCase  )
  
  							UpperCAmelCase_=     torch.tensor(
  							    [[[-39.5_397, -44.4_024, -36.1_844], [-61.4_709, -63.8_639, -58.3_454], [-74.0_225, -68.5_494, -71.2_164]]]		,						device=__UpperCAmelCase		,						)
  
  							self.assertTrue(torch.allclose(outputs.logits[0][:, 1:4, 1:4]		,						__UpperCAmelCase		,						atol=1E-4  )  )
  
  
  
  
  
style_context: 
  
  
  
  import copy
  from typing import Dict
  
  from ...generation.configuration_utils import GenerationConfig
  from ...utils import logging
  
  
  __A       					=		logging.get_logger(__name__)
  
  
  
  
  
  
  class 	lowercase		(				snake_case__):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      Optional[int]	     =							"semantic"
  
  
  
  
  	def __init__(			self			:		Any		,						__UpperCAmelCase			:		List[str]=10_000		,						__UpperCAmelCase			:		List[Any]=True		,						__UpperCAmelCase			:		int=768		,						__UpperCAmelCase			:		Dict=False		,						__UpperCAmelCase			:		str=False		,						__UpperCAmelCase			:		Optional[int]=False		,						__UpperCAmelCase			:		int=False		,						__UpperCAmelCase			:		Union[str, Any]=0.7		,						__UpperCAmelCase			:		Optional[Any]=True		,						__UpperCAmelCase			:		int=10_048		,						__UpperCAmelCase			:		Dict=129_595		,						__UpperCAmelCase			:		Optional[Any]=129_599		,						__UpperCAmelCase			:		Tuple=10_000		,						__UpperCAmelCase			:		List[Any]=256		,						__UpperCAmelCase			:		Union[str, Any]=49.9		,						**__UpperCAmelCase			:		Optional[Any]		,						)    ->				Tuple:
  							super().__init__(
  							    temperature=__UpperCAmelCase		,						do_sample=__UpperCAmelCase		,						eos_token_id=__UpperCAmelCase		,						renormalize_logits=__UpperCAmelCase		,						max_new_tokens=__UpperCAmelCase		,						output_scores=__UpperCAmelCase		,						return_dict_in_generate=__UpperCAmelCase		,						output_hidden_states=__UpperCAmelCase		,						output_attentions=__UpperCAmelCase		,						**__UpperCAmelCase		,						)
  
  							UpperCAmelCase_=     text_encoding_offset
  							UpperCAmelCase_=     text_pad_token
  							UpperCAmelCase_=     eos_token_id
  							UpperCAmelCase_=     semantic_infer_token
  							UpperCAmelCase_=     semantic_vocab_size
  							UpperCAmelCase_=     max_input_semantic_length
  							UpperCAmelCase_=     semantic_rate_hz
  
  
  
  
  
  
  class 	lowercase		(				snake_case__):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      Any	     =							"coarse_acoustics"
  
  
  
  
  	def __init__(			self			:		Union[str, Any]		,						__UpperCAmelCase			:		Optional[Any]=True		,						__UpperCAmelCase			:		Optional[int]=False		,						__UpperCAmelCase			:		Union[str, Any]=False		,						__UpperCAmelCase			:		List[str]=False		,						__UpperCAmelCase			:		Any=False		,						__UpperCAmelCase			:		Union[str, Any]=0.7		,						__UpperCAmelCase			:		List[Any]=True		,						__UpperCAmelCase			:		Optional[int]=12_048		,						__UpperCAmelCase			:		Optional[Any]=75		,						__UpperCAmelCase			:		str=2		,						__UpperCAmelCase			:		Optional[int]=12_050		,						__UpperCAmelCase			:		Union[str, Any]=256		,						__UpperCAmelCase			:		int = 630		,						__UpperCAmelCase			:		int = 60		,						**__UpperCAmelCase			:		int		,						)    ->				Union[str, Any]:
  							super().__init__(
  							    temperature=__UpperCAmelCase		,						do_sample=__UpperCAmelCase		,						renormalize_logits=__UpperCAmelCase		,						output_scores=__UpperCAmelCase		,						return_dict_in_generate=__UpperCAmelCase		,						output_hidden_states=__UpperCAmelCase		,						output_attentions=__UpperCAmelCase		,						**__UpperCAmelCase		,						)
  
  							UpperCAmelCase_=     coarse_semantic_pad_token
  							UpperCAmelCase_=     coarse_rate_hz
  							UpperCAmelCase_=     n_coarse_codebooks
  							UpperCAmelCase_=     coarse_infer_token
  							UpperCAmelCase_=     max_coarse_input_length
  							UpperCAmelCase_=     max_coarse_history
  							UpperCAmelCase_=     sliding_window_len
  
  
  
  
  
  
  class 	lowercase		(				snake_case__):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      Tuple	     =							"fine_acoustics"
  
  
  
  
  	def __init__(			self			:		Tuple		,						__UpperCAmelCase			:		Tuple=0.5		,						__UpperCAmelCase			:		Optional[Any]=512		,						__UpperCAmelCase			:		Optional[Any]=1_024		,						__UpperCAmelCase			:		List[str]=8		,						**__UpperCAmelCase			:		str		,						)    ->				Tuple:
  							super().__init__(temperature=__UpperCAmelCase  )
  
  							UpperCAmelCase_=     max_fine_history_length
  							UpperCAmelCase_=     max_fine_input_length
  							UpperCAmelCase_=     n_fine_codebooks
  
  
  
  
  
  
  class 	lowercase		(				snake_case__):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      Any	     =							"bark"
  	a__   :      List[str]	     =							True
  
  
  
  
  	def __init__(			self			:		List[str]		,						__UpperCAmelCase			:		Dict = None		,						__UpperCAmelCase			:		Dict = None		,						__UpperCAmelCase			:		Dict = None		,						__UpperCAmelCase			:		str=24_000		,						__UpperCAmelCase			:		List[str]=1_024		,						**__UpperCAmelCase			:		Optional[int]		,						)    ->				List[str]:
  							if semantic_config is None:
  													UpperCAmelCase_=     {}
  													logger.info("""semantic_config is None. initializing the semantic model with default values."""  )
  
  							if coarse_acoustics_config is None:
  													UpperCAmelCase_=     {}
  													logger.info("""coarse_acoustics_config is None. initializing the coarse model with default values."""  )
  
  							if fine_acoustics_config is None:
  													UpperCAmelCase_=     {}
  													logger.info("""fine_acoustics_config is None. initializing the fine model with default values."""  )
  
  							UpperCAmelCase_=     BarkSemanticGenerationConfig(**__UpperCAmelCase  )
  							UpperCAmelCase_=     BarkCoarseGenerationConfig(**__UpperCAmelCase  )
  							UpperCAmelCase_=     BarkFineGenerationConfig(**__UpperCAmelCase  )
  
  							UpperCAmelCase_=     sample_rate
  							UpperCAmelCase_=     codebook_size
  
  
  
  
  	@classmethod
  	def 						_SCREAMING_SNAKE_CASE	(			cls			:		str		,						__UpperCAmelCase			:		BarkSemanticGenerationConfig		,						__UpperCAmelCase			:		BarkCoarseGenerationConfig		,						__UpperCAmelCase			:		BarkFineGenerationConfig		,						**__UpperCAmelCase			:		Any		,						)    ->				Any:
  							return cls(
  							    semantic_config=semantic_config.to_dict()		,						coarse_acoustics_config=coarse_acoustics_config.to_dict()		,						fine_acoustics_config=fine_acoustics_config.to_dict()		,						**__UpperCAmelCase		,						)
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		str  )    ->				Optional[Any]:
  							UpperCAmelCase_=     copy.deepcopy(self.__dict__  )
  
  							UpperCAmelCase_=     self.semantic_config.to_dict()
  							UpperCAmelCase_=     self.coarse_acoustics_config.to_dict()
  							UpperCAmelCase_=     self.fine_acoustics_config.to_dict()
  
  							UpperCAmelCase_=     self.__class__.model_type
  							return output
  
  
  
  
  