
'''simple docstring'''







#
# This a `torch.distributed` diagnostics script that checks that all GPUs in the cluster (one or
# many nodes) can talk to each other via nccl and allocate gpu memory.
#
# To run first adjust the number of processes and nodes:
#
# python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py
#
# You may need to add --master_addr $MASTER_ADDR --master_port $MASTER_PORT if using a custom addr:port
#
# You can also use the rdzv API: --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_backend c10d
#
# use torch.distributed.launch instead of torch.distributed.run for torch < 1.9
#
# If you get a hanging in `barrier` calls you have some network issues, you may try to debug this with:
#
# NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py
#
# which should tell you what's going on behind the scenes.
#
#
# This script can be run via `srun` in the SLURM environment as well. Here is a SLURM script that
# runs on 2 nodes of 4 gpus per node:
#
# #SBATCH --job-name=test-nodes        # name
# #SBATCH --nodes=2                    # nodes
# #SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
# #SBATCH --cpus-per-task=10           # number of cores per tasks
# #SBATCH --gres=gpu:4                 # number of gpus
# #SBATCH --time 0:05:00               # maximum execution time (HH:MM:SS)
# #SBATCH --output=%x-%j.out           # output file name
#
# GPUS_PER_NODE=4
# MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
# MASTER_PORT=6000
#
# srun --jobid $SLURM_JOBID bash -c 'python -m torch.distributed.run \
# --nproc_per_node $GPUS_PER_NODE --nnodes $SLURM_NNODES --node_rank $SLURM_PROCID \
# --master_addr $MASTER_ADDR --master_port $MASTER_PORT \
# torch-distributed-gpu-test.py'
#

import fcntl
import os
import socket

import torch
import torch.distributed as dist







def        SCREAMING_SNAKE_CASE__			(     *__A			) ->			int:
	with open(__A    ,       'r'			) as fh:
		fcntl.flock(__A    ,       fcntl.LOCK_EX			)
		try:
			print(*__A			)
		finally:
			fcntl.flock(__A    ,       fcntl.LOCK_UN			)


lowercase					:							int   =      int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
lowercase					:							Dict   =      torch.device("cuda", local_rank)
lowercase					:							Union[str, Any]   =      socket.gethostname()

lowercase					:							List[str]   =      F'''[{hostname}-{local_rank}]'''

try:
					# test distributed
					dist.init_process_group("nccl")
					dist.all_reduce(torch.ones(1).to(device), op=dist.ReduceOp.SUM)
					dist.barrier()

					# test cuda is available and can allocate memory
					torch.cuda.is_available()
					torch.ones(1).cuda(local_rank)

					# global rank
					lowercase					:							List[Any]   =      dist.get_rank()
					lowercase					:							Union[str, Any]   =      dist.get_world_size()

					printflock(F'''{gpu} is OK (global rank: {rank}/{world_size})''')

					dist.barrier()
					if rank == 0:
										printflock(F'''pt={torch.__version__}, cuda={torch.version.cuda}, nccl={torch.cuda.nccl.version()}''')

except Exception:
					printflock(F'''{gpu} is broken''')
					raise



'''simple docstring'''







import unittest

from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
					from PIL import Image
else:


					class 		__UpperCAmelCase   :


												@staticmethod
												def 				lowerCamelCase       ( *lowerCAmelCase_					,     **lowerCAmelCase_						):





													"""simple docstring"""






													pass


@is_pipeline_test
@require_vision
@require_torch
class 		__UpperCAmelCase   (      unittest.TestCase		):
							__lowercase   	= MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	pipeline(
								    'zero-shot-object-detection'					,     model='hf-internal-testing/tiny-random-owlvit-object-detection'						)

								_snake_case     		=	[
								    {
								        'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
								        'candidate_labels': ['cat', 'remote', 'couch'],
								    }
								]
								return object_detector, examples


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	object_detector(examples[0]					,     threshold=0.0						)

								_snake_case     		=	len(lowerCAmelCase_						)
								self.assertGreater(lowerCAmelCase_					,     0						)
								self.assertEqual(
								    lowerCAmelCase_					,     [
								        {
								            'score': ANY(lowerCAmelCase_						),
								            'label': ANY(lowerCAmelCase_						),
								            'box': {'xmin': ANY(lowerCAmelCase_						), 'ymin': ANY(lowerCAmelCase_						), 'xmax': ANY(lowerCAmelCase_						), 'ymax': ANY(lowerCAmelCase_						)},
								        }
								        for i in range(lowerCAmelCase_						)
								    ]					,     )


							@require_tf
							@unittest.skip('Zero Shot Object Detection not implemented in TF'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass


							@require_torch
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	pipeline(
								    'zero-shot-object-detection'					,     model='hf-internal-testing/tiny-random-owlvit-object-detection'						)

								_snake_case     		=	object_detector(
								    './tests/fixtures/tests_samples/COCO/000000039769.png'					,     candidate_labels=['cat', 'remote', 'couch']					,     threshold=0.64					,     )

								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        {'score': 0.7235, 'label': 'cat', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								        {'score': 0.7218, 'label': 'remote', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								        {'score': 0.7184, 'label': 'couch', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								        {'score': 0.6748, 'label': 'remote', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								        {'score': 0.6656, 'label': 'cat', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								        {'score': 0.6614, 'label': 'couch', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								        {'score': 0.6456, 'label': 'remote', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								        {'score': 0.642, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 2_74, 'xmax': 93, 'ymax': 2_97}},
								        {'score': 0.6419, 'label': 'cat', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								    ]					,     )

								_snake_case     		=	object_detector(
								    [
								        {
								            'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
								            'candidate_labels': ['cat', 'remote', 'couch'],
								        }
								    ]					,     threshold=0.64					,     )

								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        [
								            {'score': 0.7235, 'label': 'cat', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								            {'score': 0.7218, 'label': 'remote', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								            {'score': 0.7184, 'label': 'couch', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								            {'score': 0.6748, 'label': 'remote', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								            {'score': 0.6656, 'label': 'cat', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								            {'score': 0.6614, 'label': 'couch', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								            {'score': 0.6456, 'label': 'remote', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								            {'score': 0.642, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 2_74, 'xmax': 93, 'ymax': 2_97}},
								            {'score': 0.6419, 'label': 'cat', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								        ]
								    ]					,     )


							@require_torch
							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	pipeline('zero-shot-object-detection'						)

								_snake_case     		=	object_detector(
								    'http://images.cocodataset.org/val2017/000000039769.jpg'					,     candidate_labels=['cat', 'remote', 'couch']					,     )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								        {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								        {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 3_35, 'ymin': 74, 'xmax': 3_71, 'ymax': 1_87}},
								        {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_42, 'ymax': 4_76}},
								    ]					,     )

								_snake_case     		=	object_detector(
								    [
								        {
								            'image': 'http://images.cocodataset.org/val2017/000000039769.jpg',
								            'candidate_labels': ['cat', 'remote', 'couch'],
								        },
								        {
								            'image': 'http://images.cocodataset.org/val2017/000000039769.jpg',
								            'candidate_labels': ['cat', 'remote', 'couch'],
								        },
								    ]					,     )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        [
								            {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								            {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								            {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								            {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 3_35, 'ymin': 74, 'xmax': 3_71, 'ymax': 1_87}},
								            {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_42, 'ymax': 4_76}},
								        ],
								        [
								            {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								            {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								            {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								            {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 3_35, 'ymin': 74, 'xmax': 3_71, 'ymax': 1_87}},
								            {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_42, 'ymax': 4_76}},
								        ],
								    ]					,     )


							@require_tf
							@unittest.skip('Zero Shot Object Detection not implemented in TF'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass


							@require_torch
							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	0.2
								_snake_case     		=	pipeline('zero-shot-object-detection'						)

								_snake_case     		=	object_detector(
								    'http://images.cocodataset.org/val2017/000000039769.jpg'					,     candidate_labels=['cat', 'remote', 'couch']					,     threshold=lowerCAmelCase_					,     )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								        {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								    ]					,     )




							@require_torch
							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	2
								_snake_case     		=	pipeline('zero-shot-object-detection'						)

								_snake_case     		=	object_detector(
								    'http://images.cocodataset.org/val2017/000000039769.jpg'					,     candidate_labels=['cat', 'remote', 'couch']					,     top_k=lowerCAmelCase_					,     )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								    ]					,     )

