code: 
  
  import getopt
  import json
  import os
  
  # import numpy as np
  import sys
  from collections import OrderedDict
  
  import datasets
  import numpy as np
  import torch
  from modeling_frcnn import GeneralizedRCNN
  from processing_image import Preprocess
  
  from utils import Config
  _lowerCAmelCase     :			Union[str, Any]    =False
  _lowerCAmelCase     :			Optional[int]    =Config.from_pretrained("""unc-nlp/frcnn-vg-finetuned""")
  _lowerCAmelCase     :			Optional[Any]    =datasets.Features(
      OrderedDict(
          {
              """attr_ids""": datasets.Sequence(length=CONFIG.MAX_DETECTIONS, feature=datasets.Value("""float32""")),
              """attr_probs""": datasets.Sequence(length=CONFIG.MAX_DETECTIONS, feature=datasets.Value("""float32""")),
              """boxes""": datasets.ArrayaD((CONFIG.MAX_DETECTIONS, 4), dtype="""float32"""),
              """img_id""": datasets.Value("""int32"""),
              """obj_ids""": datasets.Sequence(length=CONFIG.MAX_DETECTIONS, feature=datasets.Value("""float32""")),
              """obj_probs""": datasets.Sequence(length=CONFIG.MAX_DETECTIONS, feature=datasets.Value("""float32""")),
              """roi_features""": datasets.ArrayaD((CONFIG.MAX_DETECTIONS, 20_48), dtype="""float32"""),
              """sizes""": datasets.Sequence(length=2, feature=datasets.Value("""float32""")),
              """preds_per_image""": datasets.Value(dtype="""int32"""),
          }
      )
  )
  
  class __UpperCamelCase    :
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					def __init__(							self							,			lowerCamelCase__=sys.argv[1:]	):
  						UpperCAmelCase__:  Optional[int]		       =   None
  						UpperCAmelCase__:  List[Any]		       =   None
  						UpperCAmelCase__:  Any		       =   None
  						UpperCAmelCase__:  int		       =   1
  						UpperCAmelCase__       ,	UpperCAmelCase__:  Optional[Any]		       =   getopt.getopt(lowerCamelCase__							,			"i:o:b:s"							,			["inputdir=", "outfile=", "batch_size=", "subset_list="]	)
  						for opt, arg in opts:
  							if opt in ("-i", "--inputdir"):
  								UpperCAmelCase__:  Union[str, Any]		       =   arg
  							elif opt in ("-o", "--outfile"):
  								UpperCAmelCase__:  Tuple		       =   arg
  							elif opt in ("-b", "--batch_size"):
  								UpperCAmelCase__:  Any		       =   int(lowerCamelCase__	)
  							elif opt in ("-s", "--subset_list"):
  								UpperCAmelCase__:  List[str]		       =   arg
  
  						assert inputdir is not None  # and os.path.isdir(inputdir), f"{inputdir}"
  						assert outputfile is not None and not os.path.isfile(lowerCamelCase__	), F"{outputfile}"
  						if subset_list is not None:
  							with open(os.path.realpath(lowerCamelCase__	)	) as f:
  								UpperCAmelCase__:  Optional[int]		       =   {self._vqa_file_split()[0] for x in tryload(lowerCamelCase__	)}
  						else:
  							UpperCAmelCase__:  Optional[Any]		       =   None
  
  						UpperCAmelCase__:  Optional[int]		       =   CONFIG
  						if torch.cuda.is_available():
  							UpperCAmelCase__:  Tuple		       =   "cuda"
  						UpperCAmelCase__:  Union[str, Any]		       =   os.path.realpath(lowerCamelCase__	)
  						UpperCAmelCase__:  Any		       =   os.path.realpath(lowerCamelCase__	)
  						UpperCAmelCase__:  Optional[Any]		       =   Preprocess(self.config	)
  						UpperCAmelCase__:  Tuple		       =   GeneralizedRCNN.from_pretrained("unc-nlp/frcnn-vg-finetuned"							,			config=self.config	)
  						UpperCAmelCase__:  str		       =   batch_size if batch_size != 0 else 1
  						UpperCAmelCase__:  Optional[int]		       =   DEFAULT_SCHEMA
  
  
  
  
  
  					def       _UpperCAmelCase						(							self							,			lowerCamelCase__	):
  						UpperCAmelCase__:  Tuple		       =   int(file.split("."	)[0].split("_"	)[-1]	)
  						UpperCAmelCase__:  Tuple		       =   os.path.join(self.inputdir							,			lowerCamelCase__	)
  						return (img_id, filepath)
  
  
  
  
  
  					@property
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Tuple		       =   []
  						for i, file in enumerate(os.listdir(self.inputdir	)	):
  							if self.subset_list is not None and i not in self.subset_list:
  								continue
  							batch.append(self._vqa_file_split(lowerCamelCase__	)	)
  							if len(lowerCamelCase__	) == self.batch:
  								UpperCAmelCase__:  str		       =   batch
  								UpperCAmelCase__:  Tuple		       =   []
  								yield list(map(lowerCamelCase__							,			zip(*lowerCamelCase__	)	)	)
  
  						for i in range(1	):
  							yield list(map(lowerCamelCase__							,			zip(*lowerCamelCase__	)	)	)
  
  
  
  
  
  					def __call__(							self	):
  						# make writer
  						if not TEST:
  							UpperCAmelCase__:  Any		       =   datasets.ArrowWriter(features=self.schema							,			path=self.outputfile	)
  						# do file generator
  						for i, (img_ids, filepaths) in enumerate(self.file_generator	):
  							UpperCAmelCase__       ,	UpperCAmelCase__       ,	UpperCAmelCase__:  str		       =   self.preprocess(lowerCamelCase__	)
  							UpperCAmelCase__:  Tuple		       =   self.model(
  							    lowerCamelCase__							,			lowerCamelCase__							,			scales_yx=lowerCamelCase__							,			padding="max_detections"							,			max_detections=self.config.MAX_DETECTIONS							,			pad_value=0							,			return_tensors="np"							,			location="cpu"							,			)
  							UpperCAmelCase__:  List[Any]		       =   output_dict.pop("normalized_boxes"	)
  							if not TEST:
  								UpperCAmelCase__:  Union[str, Any]		       =   np.array(lowerCamelCase__	)
  								UpperCAmelCase__:  List[str]		       =   self.schema.encode_batch(lowerCamelCase__	)
  								writer.write_batch(lowerCamelCase__	)
  							if TEST:
  								break
  							# finalizer the writer
  						if not TEST:
  							UpperCAmelCase__       ,	UpperCAmelCase__:  Any		       =   writer.finalize()
  							print(F"Success! You wrote {num_examples} entry(s) and {num_bytes >> 2_0} mb"	)
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	try:
  		UpperCAmelCase__:  Dict		       =   json.load(SCREAMING_SNAKE_CASE			)
  		try:
  			UpperCAmelCase__:  List[Any]		       =   list(data.keys()			)
  		except Exception:
  			UpperCAmelCase__:  List[Any]		       =   [d["img_id"] for d in data]
  	except Exception:
  		try:
  			UpperCAmelCase__:  Optional[Any]		       =   eval(stream.read()			)
  		except Exception:
  			UpperCAmelCase__:  Any		       =   stream.read().split("\n"			)
  	return data
  
  
  if __name__ == "__main__":
  					_lowerCAmelCase     :			Tuple    =Extract(sys.argv[1:])
  					extract()
  					if not TEST:
  										_lowerCAmelCase     :			List[Any]    =datasets.Dataset.from_file(extract.outputfile)
  										# wala!
  										# print(np.array(dataset[0:2]["roi_features"]).shape)
style_context: 
  
  import numpy as np
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  List[Any]		       =   np.exp(SCREAMING_SNAKE_CASE			)
  
  	# Add up the all the exponentials
  	UpperCAmelCase__:  str		       =   np.sum(SCREAMING_SNAKE_CASE			)
  
  	# Divide every exponent by the sum of all exponents
  	UpperCAmelCase__:  Tuple		       =   exponent_vector / sum_of_exponents
  
  	return softmax_vector
  
  
  if __name__ == "__main__":
  					print(softmax((0,)))