





from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers.models.layoutlm.modeling_tf_layoutlm import (
          TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFLayoutLMForMaskedLM,
          TFLayoutLMForQuestionAnswering,
          TFLayoutLMForSequenceClassification,
          TFLayoutLMForTokenClassification,
          TFLayoutLMModel,
      )
class        SCREAMING_SNAKE_CASE     :


   def __init__(					self    :       List[str]    ,  a    :       Dict    ,  a    :       List[Any]=13    ,  a    :       List[str]=7    ,  a    :       Optional[int]=True    ,  a    :       str=True    ,  a    :       Optional[int]=True    ,  a    :       str=True    ,  a    :       str=99    ,  a    :       str=32    ,  a    :       List[str]=2    ,  a    :       List[str]=4    ,  a    :       Union[str, Any]=37    ,  a    :       List[str]="gelu"    ,  a    :       Dict=0.1    ,  a    :       Any=0.1    ,  a    :       Tuple=512    ,  a    :       Optional[int]=16    ,  a    :       int=2    ,  a    :       Any=0.02    ,  a    :       Any=3    ,  a    :       Dict=4    ,  a    :       List[str]=None    ,  a    :       Tuple=1_000    ,  )->     Dict:





     """simple docstring"""







     lowercase__			    =						parent
     lowercase__			    =						batch_size
     lowercase__			    =						seq_length
     lowercase__			    =						is_training
     lowercase__			    =						use_input_mask
     lowercase__			    =						use_token_type_ids
     lowercase__			    =						use_labels
     lowercase__			    =						vocab_size
     lowercase__			    =						hidden_size
     lowercase__			    =						num_hidden_layers
     lowercase__			    =						num_attention_heads
     lowercase__			    =						intermediate_size
     lowercase__			    =						hidden_act
     lowercase__			    =						hidden_dropout_prob
     lowercase__			    =						attention_probs_dropout_prob
     lowercase__			    =						max_position_embeddings
     lowercase__			    =						type_vocab_size
     lowercase__			    =						type_sequence_label_size
     lowercase__			    =						initializer_range
     lowercase__			    =						num_labels
     lowercase__			    =						num_choices
     lowercase__			    =						scope
     lowercase__			    =						range_bbox


   def  SCREAMING_SNAKE_CASE_							(					self    :       int )->     Any:





     """simple docstring"""







     lowercase__			    =						ids_tensor([self.batch_size, self.seq_length]    ,  self.vocab_size )

     # convert bbox to numpy since TF does not support item assignment
     lowercase__			    =						ids_tensor([self.batch_size, self.seq_length, 4]    ,  self.range_bbox ).numpy()
     # Ensure that bbox is legal
     for i in range(bbox.shape[0] ):
       for j in range(bbox.shape[1] ):
         if bbox[i, j, 3] < bbox[i, j, 1]:
           lowercase__			    =						bbox[i, j, 3]
           lowercase__			    =						bbox[i, j, 1]
           lowercase__			    =						t
         if bbox[i, j, 2] < bbox[i, j, 0]:
           lowercase__			    =						bbox[i, j, 2]
           lowercase__			    =						bbox[i, j, 0]
           lowercase__			    =						t
     lowercase__			    =						tf.convert_to_tensor(a )

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

     lowercase__			    =						None
     if self.use_token_type_ids:
       lowercase__			    =						ids_tensor([self.batch_size, self.seq_length]    ,  self.type_vocab_size )

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

     lowercase__			    =						LayoutLMConfig(
         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    ,  initializer_range=self.initializer_range    ,  )

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


   def  SCREAMING_SNAKE_CASE_							(					self    :       str    ,  a    :       List[Any]    ,  a    :       List[str]    ,  a    :       Union[str, Any]    ,  a    :       Union[str, Any]    ,  a    :       int    ,  a    :       Dict    ,  a    :       int    ,  a    :       Any )->     List[str]:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMModel(config=a )

     lowercase__			    =						model(a    ,  a    ,  attention_mask=a    ,  token_type_ids=a )
     lowercase__			    =						model(a    ,  a    ,  token_type_ids=a )
     lowercase__			    =						model(a    ,  a )
     self.parent.assertEqual(result.last_hidden_state.shape    ,  (self.batch_size, self.seq_length, self.hidden_size) )
     self.parent.assertEqual(result.pooler_output.shape    ,  (self.batch_size, self.hidden_size) )


   def  SCREAMING_SNAKE_CASE_							(					self    :       str    ,  a    :       Any    ,  a    :       Union[str, Any]    ,  a    :       Tuple    ,  a    :       Dict    ,  a    :       Dict    ,  a    :       Dict    ,  a    :       Tuple    ,  a    :       List[str] )->     int:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMForMaskedLM(config=a )

     lowercase__			    =						model(a    ,  a    ,  attention_mask=a    ,  token_type_ids=a    ,  labels=a )
     self.parent.assertEqual(result.logits.shape    ,  (self.batch_size, self.seq_length, self.vocab_size) )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict    ,  a    :       List[str]    ,  a    :       List[str]    ,  a    :       Union[str, Any]    ,  a    :       List[str]    ,  a    :       List[Any]    ,  a    :       Dict    ,  a    :       Any    ,  a    :       Optional[int] )->     Tuple:





     """simple docstring"""







     lowercase__			    =						self.num_labels
     lowercase__			    =						TFLayoutLMForSequenceClassification(config=a )

     lowercase__			    =						model(a    ,  a    ,  attention_mask=a    ,  token_type_ids=a )
     self.parent.assertEqual(result.logits.shape    ,  (self.batch_size, self.num_labels) )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any]    ,  a    :       Union[str, Any]    ,  a    :       Tuple    ,  a    :       Optional[Any]    ,  a    :       Optional[int]    ,  a    :       List[Any]    ,  a    :       List[str]    ,  a    :       Optional[int]    ,  a    :       List[Any] )->     List[str]:





     """simple docstring"""







     lowercase__			    =						self.num_labels
     lowercase__			    =						TFLayoutLMForTokenClassification(config=a )

     lowercase__			    =						model(a    ,  a    ,  attention_mask=a    ,  token_type_ids=a    ,  labels=a )
     self.parent.assertEqual(result.logits.shape    ,  (self.batch_size, self.seq_length, self.num_labels) )


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[Any]    ,  a    :       List[Any]    ,  a    :       Optional[Any]    ,  a    :       int    ,  a    :       int    ,  a    :       Union[str, Any]    ,  a    :       Any    ,  a    :       Optional[int]    ,  a    :       Optional[Any] )->     List[str]:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMForQuestionAnswering(config=a )

     lowercase__			    =						model(a    ,  a    ,  attention_mask=a    ,  token_type_ids=a )
     self.parent.assertEqual(result.start_logits.shape    ,  (self.batch_size, self.seq_length) )
     self.parent.assertEqual(result.end_logits.shape    ,  (self.batch_size, self.seq_length) )


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[Any] )->     Any:





     """simple docstring"""







     lowercase__			    =						self.prepare_config_and_inputs()
     (
         (
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					(
         lowercase__
     )    ,					
     )			    =						config_and_inputs
     lowercase__			    =						{
         'input_ids': input_ids,
         'bbox': bbox,
         'token_type_ids': token_type_ids,
         'attention_mask': input_mask,
     }
     return config, inputs_dict






@require_tf
class        SCREAMING_SNAKE_CASE     (UpperCAmelCase    ,			UpperCAmelCase    ,			unittest.TestCase   ):
   _UpperCamelCase					:	List[Any]				      = (
       (
           TFLayoutLMModel,
           TFLayoutLMForMaskedLM,
           TFLayoutLMForTokenClassification,
           TFLayoutLMForSequenceClassification,
           TFLayoutLMForQuestionAnswering,
       )
       if is_tf_available()
       else ()
   )
   _UpperCamelCase					:	List[str]				      = (
       {
           'feature-extraction': TFLayoutLMModel,
           'fill-mask': TFLayoutLMForMaskedLM,
           'text-classification': TFLayoutLMForSequenceClassification,
           'token-classification': TFLayoutLMForTokenClassification,
           'zero-shot': TFLayoutLMForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   _UpperCamelCase					:	List[str]				      = False
   _UpperCamelCase					:	Optional[int]				      = True
   _UpperCamelCase					:	Optional[int]				      = 10


   def  SCREAMING_SNAKE_CASE_							(					self    :       str )->     int:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMModelTester(self )
     lowercase__			    =						ConfigTester(self    ,  config_class=a    ,  hidden_size=37 )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[int] )->     str:





     """simple docstring"""







     self.config_tester.run_common_tests()


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     List[Any]:





     """simple docstring"""







     lowercase__			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       str )->     Dict:





     """simple docstring"""







     lowercase__			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_lm(*a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       int )->     List[str]:





     """simple docstring"""







     lowercase__			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_sequence_classification(*a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Any:





     """simple docstring"""







     lowercase__			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*a )


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       List[Any] )->     Tuple:





     """simple docstring"""







     for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       lowercase__			    =						TFLayoutLMModel.from_pretrained(a )
       self.assertIsNotNone(a )


   @unittest.skip('Onnx compliancy broke with TF 2.10' )
   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any] )->     str:





     """simple docstring"""







     pass






def     __UpperCamelCase						()       ->     Tuple:
  # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
  # fmt: off
  lowercase__			    =						tf.convert_to_tensor([[101,1019,1014,1016,1037,12849,4747,1004,14246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,11300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,19274,2772,6205,27814,16147,16147,4343,2047,10283,10969,14389,1012,2338,102]]	)  # noqa: E231
  lowercase__			    =						tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]	)  # noqa: E231
  lowercase__			    =						tf.convert_to_tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1000,1000,1000,1000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1000,1000,1000,1000]]]	)  # noqa: E231
  lowercase__			    =						tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]	)  # noqa: E231
  # these are sequence labels (i.e. at the token level)
  lowercase__			    =						tf.convert_to_tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]]	)  # noqa: E231
  # fmt: on

  return input_ids, attention_mask, bbox, token_type_ids, labels


@require_tf
class        SCREAMING_SNAKE_CASE     (unittest.TestCase   ):


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Any:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased' )

     lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__			    =						prepare_layoutlm_batch_inputs()

     # forward pass
     lowercase__			    =						model(input_ids=a    ,  bbox=a    ,  attention_mask=a    ,  token_type_ids=a )

     # test the sequence output on [0, :3, :3]
     lowercase__			    =						tf.convert_to_tensor(
         [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]    ,  )

     self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]    ,  a    ,  atol=1E-3 ) )

     # test the pooled output on [1, :3]
     lowercase__			    =						tf.convert_to_tensor([-0.6580, -0.0214, 0.8552] )

     self.assertTrue(np.allclose(outputs.pooler_output[1, :3]    ,  a    ,  atol=1E-3 ) )


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       List[Any] )->     List[str]:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'    ,  num_labels=2 )

     lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__			    =						prepare_layoutlm_batch_inputs()

     # forward pass
     lowercase__			    =						model(
         input_ids=a    ,  bbox=a    ,  attention_mask=a    ,  token_type_ids=a    ,  labels=tf.convert_to_tensor([1, 1] )    ,  )

     # test whether we get a loss as a scalar
     lowercase__			    =						outputs.loss
     lowercase__			    =						(2,)
     self.assertEqual(loss.shape    ,  a )

     # test the shape of the logits
     lowercase__			    =						outputs.logits
     lowercase__			    =						(2, 2)
     self.assertEqual(logits.shape    ,  a )


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any] )->     Tuple:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'    ,  num_labels=13 )

     lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__			    =						prepare_layoutlm_batch_inputs()

     # forward pass
     lowercase__			    =						model(
         input_ids=a    ,  bbox=a    ,  attention_mask=a    ,  token_type_ids=a    ,  labels=a )

     # test the shape of the logits
     lowercase__			    =						outputs.logits
     lowercase__			    =						tf.convert_to_tensor((2, 25, 13) )
     self.assertEqual(logits.shape    ,  a )


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       Union[str, Any] )->     List[str]:





     """simple docstring"""







     lowercase__			    =						TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased' )

     lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__			    =						prepare_layoutlm_batch_inputs()

     # forward pass
     lowercase__			    =						model(input_ids=a    ,  bbox=a    ,  attention_mask=a    ,  token_type_ids=a )

     # test the shape of the logits
     lowercase__			    =						tf.convert_to_tensor((2, 25) )
     self.assertEqual(outputs.start_logits.shape    ,  a )
     self.assertEqual(outputs.end_logits.shape    ,  a )









import numpy as np
import torch
import tqdm

from ...models.unet_ad import UNetaDModel
from ...pipelines import DiffusionPipeline
from ...utils import randn_tensor
from ...utils.dummy_pt_objects import DDPMScheduler
class        SCREAMING_SNAKE_CASE     (UpperCAmelCase   ):


   def __init__(					self    :       Optional[Any]    ,  a    :       UNetaDModel    ,  a    :       UNetaDModel    ,  a    :       DDPMScheduler    ,  a    :       Any    ,  )->     Dict:





     """simple docstring"""







     super().__init__()
     lowercase__			    =						value_function
     lowercase__			    =						unet
     lowercase__			    =						scheduler
     lowercase__			    =						env
     lowercase__			    =						env.get_dataset()
     lowercase__			    =						{}
     for key in self.data.keys():
       try:
         lowercase__			    =						self.data[key].mean()
       except:  # noqa: E722
         pass
     lowercase__			    =						{}
     for key in self.data.keys():
       try:
         lowercase__			    =						self.data[key].std()
       except:  # noqa: E722
         pass
     lowercase__			    =						env.observation_space.shape[0]
     lowercase__			    =						env.action_space.shape[0]


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any]    ,  a    :       Any    ,  a    :       int )->     Dict:





     """simple docstring"""







     return (x_in - self.means[key]) / self.stds[key]


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[int]    ,  a    :       str    ,  a    :       List[str] )->     str:





     """simple docstring"""







     return x_in * self.stds[key] + self.means[key]


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str]    ,  a    :       Tuple )->     Tuple:





     """simple docstring"""







     if type(a ) is dict:
       return {k: self.to_torch(a ) for k, v in x_in.items()}
     elif torch.is_tensor(a ):
       return x_in.to(self.unet.device )
     return torch.tensor(a    ,  device=self.unet.device )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any]    ,  a    :       Optional[int]    ,  a    :       Dict    ,  a    :       Optional[Any] )->     List[Any]:





     """simple docstring"""







     for key, val in cond.items():
       lowercase__			    =						val.clone()
     return x_in


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple    ,  a    :       Optional[Any]    ,  a    :       Any    ,  a    :       Optional[Any]    ,  a    :       Optional[int] )->     List[Any]:





     """simple docstring"""







     lowercase__			    =						x.shape[0]
     lowercase__			    =						None
     for i in tqdm.tqdm(self.scheduler.timesteps ):
       # create batch of timesteps to pass into model
       lowercase__			    =						torch.full((batch_size,)    ,  a    ,  device=self.unet.device    ,  dtype=torch.long )
       for _ in range(a ):
         with torch.enable_grad():
           x.requires_grad_()

           # permute to match dimension for pre-trained models
           lowercase__			    =						self.value_function(x.permute(0    ,  2    ,  1 )    ,  a ).sample
           lowercase__			    =						torch.autograd.grad([y.sum()]    ,  [x] )[0]

           lowercase__			    =						self.scheduler._get_variance(a )
           lowercase__			    =						torch.exp(0.5 * posterior_variance )
           lowercase__			    =						model_std * grad

         lowercase__			    =						0
         lowercase__			    =						x.detach()
         lowercase__			    =						x + scale * grad
         lowercase__			    =						self.reset_xa(a    ,  a    ,  self.action_dim )

       lowercase__			    =						self.unet(x.permute(0    ,  2    ,  1 )    ,  a ).sample.permute(0    ,  2    ,  1 )

       # TODO: verify deprecation of this kwarg
       lowercase__			    =						self.scheduler.step(a    ,  a    ,  a    ,  predict_epsilon=a )['prev_sample']

       # apply conditions to the trajectory (set the initial state)
       lowercase__			    =						self.reset_xa(a    ,  a    ,  self.action_dim )
       lowercase__			    =						self.to_torch(a )
     return x, y


   def __call__(					self    :       Any    ,  a    :       Tuple    ,  a    :       int=64    ,  a    :       Tuple=32    ,  a    :       List[Any]=2    ,  a    :       List[str]=0.1 )->     List[Any]:





     """simple docstring"""







     lowercase__			    =						self.normalize(a    ,  'observations' )
     lowercase__			    =						obs[None].repeat(a    ,  axis=0 )

     lowercase__			    =						{0: self.to_torch(a )}
     lowercase__			    =						(batch_size, planning_horizon, self.state_dim + self.action_dim)

     # generate initial noise and apply our conditions (to make the trajectories start at current state)
     lowercase__			    =						randn_tensor(a    ,  device=self.unet.device )
     lowercase__			    =						self.reset_xa(a    ,  a    ,  self.action_dim )
     lowercase__			    =						self.to_torch(a )

     # run the diffusion process
     lowercase__    ,					lowercase__			    =						self.run_diffusion(a    ,  a    ,  a    ,  a )

     # sort output trajectories by value
     lowercase__			    =						y.argsort(0    ,  descending=a ).squeeze()
     lowercase__			    =						x[sorted_idx]
     lowercase__			    =						sorted_values[:, :, : self.action_dim]
     lowercase__			    =						actions.detach().cpu().numpy()
     lowercase__			    =						self.de_normalize(a    ,  key='actions' )

     # select the action with the highest value
     if y is not None:
       lowercase__			    =						0
     else:
       # if we didn't run value guiding, select a random action
       lowercase__			    =						np.random.randint(0    ,  a )

     lowercase__			    =						denorm_actions[selected_index, 0]
     return denorm_actions


