code: 
  
  
  
  
  
  
  """simple docstring"""
  import argparse
  import os
  
  
  snake_case   :   Dict    		=		{
      """pytorch""": {
          """1.13""": {
              """torch""": """1.13.1""",
              """torchvision""": """0.14.1""",
              """torchaudio""": """0.13.1""",
              """python""": 3.9,
              """cuda""": """cu116""",
              """install""": (
                  """python3 -m pip install --no-cache-dir -U torch==1.13.1 torchvision==0.14.1 torchaudio==0.13.1"""
                  """ --extra-index-url https://download.pytorch.org/whl/cu116"""
              ),
              """base_image""": """nvidia/cuda:11.6.2-cudnn8-devel-ubuntu20.04""",
          },
          """1.12""": {
              """torch""": """1.12.1""",
              """torchvision""": """0.13.1""",
              """torchaudio""": """0.12.1""",
              """python""": 3.9,
              """cuda""": """cu113""",
              """install""": (
                  """python3 -m pip install --no-cache-dir -U torch==1.12.1 torchvision==0.13.1 torchaudio==0.12.1"""
                  """ --extra-index-url https://download.pytorch.org/whl/cu113"""
              ),
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
          """1.11""": {
              """torch""": """1.11.0""",
              """torchvision""": """0.12.0""",
              """torchaudio""": """0.11.0""",
              """python""": 3.9,
              """cuda""": """cu113""",
              """install""": (
                  """python3 -m pip install --no-cache-dir -U torch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0"""
                  """ --extra-index-url https://download.pytorch.org/whl/cu113"""
              ),
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
          """1.10""": {
              """torch""": """1.10.2""",
              """torchvision""": """0.11.3""",
              """torchaudio""": """0.10.2""",
              """python""": 3.9,
              """cuda""": """cu113""",
              """install""": (
                  """python3 -m pip install --no-cache-dir -U torch==1.10.2 torchvision==0.11.3 torchaudio==0.10.2"""
                  """ --extra-index-url https://download.pytorch.org/whl/cu113"""
              ),
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
          # torchaudio < 0.10 has no CUDA-enabled binary distributions
          """1.9""": {
              """torch""": """1.9.1""",
              """torchvision""": """0.10.1""",
              """torchaudio""": """0.9.1""",
              """python""": 3.9,
              """cuda""": """cu111""",
              """install""": (
                  """python3 -m pip install --no-cache-dir -U torch==1.9.1 torchvision==0.10.1 torchaudio==0.9.1"""
                  """ --extra-index-url https://download.pytorch.org/whl/cu111"""
              ),
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
      },
      """tensorflow""": {
          """2.11""": {
              """tensorflow""": """2.11.1""",
              """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.11.1""",
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
          """2.10""": {
              """tensorflow""": """2.10.1""",
              """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.10.1""",
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
          """2.9""": {
              """tensorflow""": """2.9.3""",
              """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.9.3""",
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
          """2.8""": {
              """tensorflow""": """2.8.2""",
              """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.8.2""",
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
          """2.7""": {
              """tensorflow""": """2.7.3""",
              """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.7.3""",
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
          """2.6""": {
              """tensorflow""": """2.6.5""",
              """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.6.5""",
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
          """2.5""": {
              """tensorflow""": """2.5.3""",
              """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.5.3""",
              """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
          },
      },
  }
  
  
  if __name__ == "__main__":
   snake_case   :   Any    		=		argparse.ArgumentParser("""Choose the framework and version to install""")
   parser.add_argument(
       """--framework""", help="""The framework to install. Should be `torch` or `tensorflow`""", type=str, required=True
   )
   parser.add_argument("""--version""", help="""The version of the framework to install.""", type=str, required=True)
   snake_case   :   List[Any]    		=		parser.parse_args()
  
   snake_case   :   int    		=		past_versions_testing[args.framework][args.version]
  
   os.system(f"""echo \"export INSTALL_CMD=\'{info['install']}\'\" >> ~/.profile""")
   print(f"""echo \"export INSTALL_CMD=\'{info['install']}\'\" >> ~/.profile""")
  
   snake_case   :   Tuple    		=		""""""
   if args.framework == "pytorch":
    snake_case   :   int    		=		info["""cuda"""]
   os.system(f"""echo \"export CUDA='{cuda}'\" >> ~/.profile""")
   print(f"""echo \"export CUDA='{cuda}'\" >> ~/.profile""")
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  import numpy as np
  
  
  def        A	(							__snake_case:   Any   ,    __snake_case:   List[str]   ,    __snake_case:   Tuple     )						->		Dict:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						n_draws * class_counts / class_counts.sum()
         # floored means we don't overshoot n_samples, but probably undershoot
         __magic_name__										=						np.floor(__snake_case     )
         # we add samples according to how much "left over" probability
         # they had, until we arrive at n_samples
         __magic_name__										=						int(n_draws - floored.sum()     )
         if need_to_add > 0:
                __magic_name__										=						continuous - floored
                __magic_name__										=						np.sort(np.unique(__snake_case     )     )[::-1]
                # add according to remainder, but break ties
                # randomly to avoid biases
                for value in values:
                       ((__magic_name__)							,     )										=						np.where(remainder == value     )
                       # if we need_to_add less than what's in inds
                       # we draw randomly from them.
                       # if we need to add more, we add them all and
                       # go to the next value
                       __magic_name__										=						min(len(__snake_case     )   ,    __snake_case     )
                       __magic_name__										=						rng.choice(__snake_case   ,    size=__snake_case   ,    replace=__snake_case     )
                       floored[inds] += 1
                       need_to_add -= add_now
                       if need_to_add == 0:
                              break
         return floored.astype(np.intaa     )
  
  
  
  
  
  
  def        A	(							__snake_case:   Any   ,    __snake_case:   str   ,    __snake_case:   int   ,    __snake_case:   Optional[Any]   ,    __snake_case:   Any=1_0     )						->		Any:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__							,     __magic_name__										=						np.unique(__snake_case   ,    return_inverse=__snake_case     )
         __magic_name__										=						classes.shape[0]
         __magic_name__										=						np.bincount(__snake_case     )
         if np.min(__snake_case     ) < 2:
                raise ValueError('Minimum class count error'     )
         if n_train < n_classes:
                raise ValueError(
                    'The train_size = %d should be greater or ' 'equal to the number of classes = %d' % (n_train, n_classes)     )
         if n_test < n_classes:
                raise ValueError(
                    'The test_size = %d should be greater or ' 'equal to the number of classes = %d' % (n_test, n_classes)     )
         __magic_name__										=						np.split(np.argsort(__snake_case   ,    kind='mergesort'     )   ,    np.cumsum(__snake_case     )[:-1]     )
         for _ in range(__snake_case     ):
                __magic_name__										=						approximate_mode(__snake_case   ,    __snake_case   ,    __snake_case     )
                __magic_name__										=						class_counts - n_i
                __magic_name__										=						approximate_mode(__snake_case   ,    __snake_case   ,    __snake_case     )
  
                __magic_name__										=						[]
                __magic_name__										=						[]
  
                for i in range(__snake_case     ):
                       __magic_name__										=						rng.permutation(class_counts[i]     )
                       __magic_name__										=						class_indices[i].take(__snake_case   ,    mode='clip'     )
                       train.extend(perm_indices_class_i[: n_i[i]]     )
                       test.extend(perm_indices_class_i[n_i[i] : n_i[i] + t_i[i]]     )
                __magic_name__										=						rng.permutation(__snake_case     )
                __magic_name__										=						rng.permutation(__snake_case     )
  
                yield train, test