


def  a   ():
   return [list(range(1_000 - i		,				-1_000 - i		,				-1   )   ) for i in range(1_000   )]


SCREAMING_SNAKE_CASE							    =							generate_large_matrix()
SCREAMING_SNAKE_CASE							    =							(
    [[4, 3, 2, -1], [3, 2, 1, -1], [1, 1, -1, -2], [-1, -1, -2, -3]],
    [[3, 2], [1, 0]],
    [[7, 7, 6]],
    [[7, 7, 6], [-1, -2, -3]],
    grid,
)




def  a   (lowerCAmelCase__   ):
   assert all(row == sorted(lowerCAmelCase__		,				reverse=lowerCAmelCase__   ) for row in grid   )
   assert all(list(lowerCAmelCase__   ) == sorted(lowerCAmelCase__		,				reverse=lowerCAmelCase__   ) for col in zip(*lowerCAmelCase__   )   )




def  a   (lowerCAmelCase__   ):
   __a					=  0
   __a					=  len(lowerCAmelCase__   ) - 1

   # Edge cases such as no values or all numbers are negative.
   if not array or array[0] < 0:
      return 0

   while right + 1 > left:
      __a					=  (left + right) // 2
      __a					=  array[mid]

      # Num must be negative and the index must be greater than or equal to 0.
      if num < 0 and array[mid - 1] >= 0:
         return mid

      if num >= 0:
         __a					=  mid + 1
      else:
         __a					=  mid - 1
    # No negative numbers so return the last index of the array + 1 which is the length.
   return len(lowerCAmelCase__   )




def  a   (lowerCAmelCase__   ):
   __a					=  0
   __a					=  len(grid[0]   )

   for i in range(len(lowerCAmelCase__   )   ):
      __a					=  find_negative_index(grid[i][:bound]   )
      total += bound
   return (len(lowerCAmelCase__   ) * len(grid[0]   )) - total




def  a   (lowerCAmelCase__   ):
   return len([number for row in grid for number in row if number < 0]   )




def  a   (lowerCAmelCase__   ):
   __a					=  0
   for row in grid:
      for i, number in enumerate(lowerCAmelCase__   ):
         if number < 0:
            total += len(lowerCAmelCase__   ) - i
            break
   return total




def  a   ():
   from timeit import timeit

   print("""Running benchmarks"""   )
   __a					=  (
       """from __main__ import count_negatives_binary_search, """
       """count_negatives_brute_force, count_negatives_brute_force_with_break, grid"""
   )
   for func in (
       "count_negatives_binary_search",  # took 0.7727 seconds
       "count_negatives_brute_force_with_break",  # took 4.6505 seconds
       "count_negatives_brute_force",  # took 12.8160 seconds
   ):
      __a					=  timeit(f'''{func}(grid=grid)'''		,				setup=lowerCAmelCase__		,				number=500   )
      print(f'''{func}() took {time:0.4f} seconds'''   )


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  benchmark()







import json
import os
from collections import Counter

import torch
import torchvision
import torchvision.transforms as transforms
from PIL import Image
from torch import nn
from torch.utils.data import Dataset


SCREAMING_SNAKE_CASE							    =							{1: (1, 1), 2: (2, 1), 3: (3, 1), 4: (2, 2), 5: (5, 1), 6: (3, 2), 7: (7, 1), 8: (4, 2), 9: (3, 3)}


class     __UpperCAmelCase							(       nn.Module							):


     """simple docstring"""


     def __init__(	self  ,       __A    ):
        super().__init__()
        __a					=  torchvision.models.resnetaaa(pretrained=__A    )
        __a					=  list(model.children()    )[:-2]
        __a					=  nn.Sequential(*__A    )
        __a					=  nn.AdaptiveAvgPoolad(POOLING_BREAKDOWN[args.num_image_embeds]    )


     def 	snake_case_  (	self  ,       __A    ):
        # Bx3x224x224 -> Bx2048x7x7 -> Bx2048xN -> BxNx2048
        __a					=  self.pool(self.model(__A    )    )
        __a					=  torch.flatten(__A  ,       start_dim=2    )
        __a					=  out.transpose(1  ,       2    ).contiguous()
        return out  # BxNx2048







class     __UpperCAmelCase							(       __A							):


     """simple docstring"""


     def __init__(	self  ,       __A  ,       __A  ,       __A  ,       __A  ,       __A    ):
        __a					=  [json.loads(__A    ) for l in open(__A    )]
        __a					=  os.path.dirname(__A    )
        __a					=  tokenizer
        __a					=  labels
        __a					=  len(__A    )
        __a					=  max_seq_length

        __a					=  transforms


     def __len__(	self    ):
        return len(self.data    )


     def __getitem__(	self  ,       __A    ):
        __a					=  torch.LongTensor(self.tokenizer.encode(self.data[index]["""text"""]  ,       add_special_tokens=__A    )    )
        __a	,    __a	,    __a					=  sentence[0], sentence[1:-1], sentence[-1]
        __a					=  sentence[: self.max_seq_length]

        __a					=  torch.zeros(self.n_classes    )
        __a					=  1

        __a					=  Image.open(os.path.join(self.data_dir  ,       self.data[index]["""img"""]    )    ).convert("""RGB"""    )
        __a					=  self.transforms(__A    )

        return {
            "image_start_token": start_token,
            "image_end_token": end_token,
            "sentence": sentence,
            "image": image,
            "label": label,
        }


     def 	snake_case_  (	self    ):
        __a					=  Counter()
        for row in self.data:
           label_freqs.update(row["""label"""]    )
        return label_freqs







def  a   (lowerCAmelCase__   ):
   __a					=  [len(row["""sentence"""]   ) for row in batch]
   __a	,    __a					=  len(lowerCAmelCase__   ), max(lowerCAmelCase__   )

   __a					=  torch.zeros(lowerCAmelCase__		,				lowerCAmelCase__		,				dtype=torch.long   )
   __a					=  torch.zeros(lowerCAmelCase__		,				lowerCAmelCase__		,				dtype=torch.long   )

   for i_batch, (input_row, length) in enumerate(zip(lowerCAmelCase__		,				lowerCAmelCase__   )   ):
      __a					=  input_row["""sentence"""]
      __a					=  1

   __a					=  torch.stack([row["""image"""] for row in batch]   )
   __a					=  torch.stack([row["""label"""] for row in batch]   )
   __a					=  torch.stack([row["""image_start_token"""] for row in batch]   )
   __a					=  torch.stack([row["""image_end_token"""] for row in batch]   )

   return text_tensor, mask_tensor, img_tensor, img_start_token, img_end_token, tgt_tensor




def  a   ():
   return [
       "Crime",
       "Drama",
       "Thriller",
       "Action",
       "Comedy",
       "Romance",
       "Documentary",
       "Short",
       "Mystery",
       "History",
       "Family",
       "Adventure",
       "Fantasy",
       "Sci-Fi",
       "Western",
       "Horror",
       "Sport",
       "War",
       "Music",
       "Musical",
       "Animation",
       "Biography",
       "Film-Noir",
   ]




def  a   ():
   return transforms.Compose(
       [
           transforms.Resize(256   ),
           transforms.CenterCrop(224   ),
           transforms.ToTensor(),
           transforms.Normalize(
               mean=[0.4_6_7_7_7_0_4_4, 0.4_4_5_3_1_4_2_9, 0.4_0_6_6_1_0_1_7]		,				std=[0.1_2_2_2_1_9_9_4, 0.1_2_1_4_5_8_3_5, 0.1_4_3_8_0_4_6_9]		,				),
       ]   )



