




import collections
import inspect
import unittest

from transformers import FocalNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import (
         FocalNetBackbone,
         FocalNetForImageClassification,
         FocalNetForMaskedImageModeling,
         FocalNetModel,
     )
     from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor





class 					__lowerCamelCase			:




    """simple docstring"""

    def __init__(			self	:	Optional[int]  ,      SCREAMING_SNAKE_CASE__	:	Optional[Any]  ,      SCREAMING_SNAKE_CASE__	:	Tuple=13  ,      SCREAMING_SNAKE_CASE__	:	Union[str, Any]=32  ,      SCREAMING_SNAKE_CASE__	:	int=2  ,      SCREAMING_SNAKE_CASE__	:	str=3  ,      SCREAMING_SNAKE_CASE__	:	Tuple=16  ,      SCREAMING_SNAKE_CASE__	:	Optional[Any]=[32, 64, 128]  ,      SCREAMING_SNAKE_CASE__	:	Optional[Any]=[1, 2, 1]  ,      SCREAMING_SNAKE_CASE__	:	Optional[int]=[2, 2, 4]  ,      SCREAMING_SNAKE_CASE__	:	Any=2  ,      SCREAMING_SNAKE_CASE__	:	List[Any]=2.0  ,      SCREAMING_SNAKE_CASE__	:	Dict=True  ,      SCREAMING_SNAKE_CASE__	:	Any=0.0  ,      SCREAMING_SNAKE_CASE__	:	List[str]=0.0  ,      SCREAMING_SNAKE_CASE__	:	Dict=0.1  ,      SCREAMING_SNAKE_CASE__	:	List[Any]="gelu"  ,      SCREAMING_SNAKE_CASE__	:	Any=False  ,      SCREAMING_SNAKE_CASE__	:	Tuple=True  ,      SCREAMING_SNAKE_CASE__	:	Any=0.02  ,      SCREAMING_SNAKE_CASE__	:	Dict=1e-5  ,      SCREAMING_SNAKE_CASE__	:	Any=True  ,      SCREAMING_SNAKE_CASE__	:	Tuple=None  ,      SCREAMING_SNAKE_CASE__	:	Any=True  ,      SCREAMING_SNAKE_CASE__	:	Optional[Any]=10  ,      SCREAMING_SNAKE_CASE__	:	Optional[int]=8  ,      SCREAMING_SNAKE_CASE__	:	Tuple=["stage1", "stage2"]  ,      SCREAMING_SNAKE_CASE__	:	Dict=[1, 2]  ,      ) ->			Any:
         lowerCAmelCase__            =					parent
         lowerCAmelCase__            =					batch_size
         lowerCAmelCase__            =					image_size
         lowerCAmelCase__            =					patch_size
         lowerCAmelCase__            =					num_channels
         lowerCAmelCase__            =					embed_dim
         lowerCAmelCase__            =					hidden_sizes
         lowerCAmelCase__            =					depths
         lowerCAmelCase__            =					num_heads
         lowerCAmelCase__            =					window_size
         lowerCAmelCase__            =					mlp_ratio
         lowerCAmelCase__            =					qkv_bias
         lowerCAmelCase__            =					hidden_dropout_prob
         lowerCAmelCase__            =					attention_probs_dropout_prob
         lowerCAmelCase__            =					drop_path_rate
         lowerCAmelCase__            =					hidden_act
         lowerCAmelCase__            =					use_absolute_embeddings
         lowerCAmelCase__            =					patch_norm
         lowerCAmelCase__            =					layer_norm_eps
         lowerCAmelCase__            =					initializer_range
         lowerCAmelCase__            =					is_training
         lowerCAmelCase__            =					scope
         lowerCAmelCase__            =					use_labels
         lowerCAmelCase__            =					type_sequence_label_size
         lowerCAmelCase__            =					encoder_stride
         lowerCAmelCase__            =					out_features
         lowerCAmelCase__            =					out_indices


    def   a (			self	:	int  ) ->			Any:
         lowerCAmelCase__            =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

         lowerCAmelCase__            =					None
         if self.use_labels:
              lowerCAmelCase__            =					ids_tensor([self.batch_size]  ,      self.type_sequence_label_size  )

         lowerCAmelCase__            =					self.get_config()

         return config, pixel_values, labels


    def   a (			self	:	int  ) ->			int:
         return FocalNetConfig(
             image_size=self.image_size  ,      patch_size=self.patch_size  ,      num_channels=self.num_channels  ,      embed_dim=self.embed_dim  ,      hidden_sizes=self.hidden_sizes  ,      depths=self.depths  ,      num_heads=self.num_heads  ,      window_size=self.window_size  ,      mlp_ratio=self.mlp_ratio  ,      qkv_bias=self.qkv_bias  ,      hidden_dropout_prob=self.hidden_dropout_prob  ,      attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,      drop_path_rate=self.drop_path_rate  ,      hidden_act=self.hidden_act  ,      use_absolute_embeddings=self.use_absolute_embeddings  ,      path_norm=self.patch_norm  ,      layer_norm_eps=self.layer_norm_eps  ,      initializer_range=self.initializer_range  ,      encoder_stride=self.encoder_stride  ,      out_features=self.out_features  ,      out_indices=self.out_indices  ,      )


    def   a (			self	:	Tuple  ,      SCREAMING_SNAKE_CASE__	:	Optional[Any]  ,      SCREAMING_SNAKE_CASE__	:	Optional[int]  ,      SCREAMING_SNAKE_CASE__	:	Optional[int]  ) ->			int:
         lowerCAmelCase__            =					FocalNetModel(config=SCREAMING_SNAKE_CASE__  )
         model.to(SCREAMING_SNAKE_CASE__  )
         model.eval()
         lowerCAmelCase__            =					model(SCREAMING_SNAKE_CASE__  )

         lowerCAmelCase__            =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
         lowerCAmelCase__            =					int(config.embed_dim * 2 ** (len(config.depths  ) - 1)  )

         self.parent.assertEqual(result.last_hidden_state.shape  ,      (self.batch_size, expected_seq_len, expected_dim)  )


    def   a (			self	:	Tuple  ,      SCREAMING_SNAKE_CASE__	:	Any  ,      SCREAMING_SNAKE_CASE__	:	Union[str, Any]  ,      SCREAMING_SNAKE_CASE__	:	List[Any]  ) ->			Any:
         lowerCAmelCase__            =					FocalNetBackbone(config=SCREAMING_SNAKE_CASE__  )
         model.to(SCREAMING_SNAKE_CASE__  )
         model.eval()
         lowerCAmelCase__            =					model(SCREAMING_SNAKE_CASE__  )

         # verify feature maps
         self.parent.assertEqual(len(result.feature_maps  )  ,      len(config.out_features  )  )
         self.parent.assertListEqual(list(result.feature_maps[0].shape  )  ,      [self.batch_size, self.image_size, 8, 8]  )

         # verify channels
         self.parent.assertEqual(len(model.channels  )  ,      len(config.out_features  )  )
         self.parent.assertListEqual(model.channels  ,      config.hidden_sizes[:-1]  )

         # verify backbone works with out_features=None
         lowerCAmelCase__            =					None
         lowerCAmelCase__            =					FocalNetBackbone(config=SCREAMING_SNAKE_CASE__  )
         model.to(SCREAMING_SNAKE_CASE__  )
         model.eval()
         lowerCAmelCase__            =					model(SCREAMING_SNAKE_CASE__  )

         # verify feature maps
         self.parent.assertEqual(len(result.feature_maps  )  ,      1  )
         self.parent.assertListEqual(list(result.feature_maps[0].shape  )  ,      [self.batch_size, self.image_size * 2, 4, 4]  )

         # verify channels
         self.parent.assertEqual(len(model.channels  )  ,      1  )
         self.parent.assertListEqual(model.channels  ,      [config.hidden_sizes[-1]]  )


    def   a (			self	:	Tuple  ,      SCREAMING_SNAKE_CASE__	:	Optional[Any]  ,      SCREAMING_SNAKE_CASE__	:	str  ,      SCREAMING_SNAKE_CASE__	:	Any  ) ->			List[Any]:
         lowerCAmelCase__            =					FocalNetForMaskedImageModeling(config=SCREAMING_SNAKE_CASE__  )
         model.to(SCREAMING_SNAKE_CASE__  )
         model.eval()
         lowerCAmelCase__            =					model(SCREAMING_SNAKE_CASE__  )
         self.parent.assertEqual(
             result.reconstruction.shape  ,      (self.batch_size, self.num_channels, self.image_size, self.image_size)  )

         # test greyscale images
         lowerCAmelCase__            =					1
         lowerCAmelCase__            =					FocalNetForMaskedImageModeling(SCREAMING_SNAKE_CASE__  )
         model.to(SCREAMING_SNAKE_CASE__  )
         model.eval()

         lowerCAmelCase__            =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
         lowerCAmelCase__            =					model(SCREAMING_SNAKE_CASE__  )
         self.parent.assertEqual(result.reconstruction.shape  ,      (self.batch_size, 1, self.image_size, self.image_size)  )


    def   a (			self	:	int  ,      SCREAMING_SNAKE_CASE__	:	str  ,      SCREAMING_SNAKE_CASE__	:	Dict  ,      SCREAMING_SNAKE_CASE__	:	str  ) ->			Optional[int]:
         lowerCAmelCase__            =					self.type_sequence_label_size
         lowerCAmelCase__            =					FocalNetForImageClassification(SCREAMING_SNAKE_CASE__  )
         model.to(SCREAMING_SNAKE_CASE__  )
         model.eval()
         lowerCAmelCase__            =					model(SCREAMING_SNAKE_CASE__  ,      labels=SCREAMING_SNAKE_CASE__  )
         self.parent.assertEqual(result.logits.shape  ,      (self.batch_size, self.type_sequence_label_size)  )

         # test greyscale images
         lowerCAmelCase__            =					1
         lowerCAmelCase__            =					FocalNetForImageClassification(SCREAMING_SNAKE_CASE__  )
         model.to(SCREAMING_SNAKE_CASE__  )
         model.eval()

         lowerCAmelCase__            =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
         lowerCAmelCase__            =					model(SCREAMING_SNAKE_CASE__  )
         self.parent.assertEqual(result.logits.shape  ,      (self.batch_size, self.type_sequence_label_size)  )


    def   a (			self	:	Union[str, Any]  ) ->			Any:
         lowerCAmelCase__            =					self.prepare_config_and_inputs()

         lowerCAmelCase__      ,						lowerCAmelCase__      ,						lowerCAmelCase__            =					config_and_inputs
         lowerCAmelCase__            =					{"pixel_values": pixel_values}
         return config, inputs_dict






@require_torch
class 					__lowerCamelCase			(       UpperCamelCase__      ,							UpperCamelCase__      ,							unittest.TestCase       ):




    """simple docstring"""

    snake_case__   = (
        (
            FocalNetModel,
            FocalNetForImageClassification,
            FocalNetForMaskedImageModeling,
            FocalNetBackbone,
        )
        if is_torch_available()
        else ()
    )
    snake_case__   = (
        {"feature-extraction": FocalNetModel, "image-classification": FocalNetForImageClassification}
        if is_torch_available()
        else {}
    )
    snake_case__   = False

    snake_case__   = False
    snake_case__   = False
    snake_case__   = False
    snake_case__   = False


    def   a (			self	:	Optional[Any]  ) ->			Dict:
         lowerCAmelCase__            =					FocalNetModelTester(self  )
         lowerCAmelCase__            =					ConfigTester(self  ,      config_class=SCREAMING_SNAKE_CASE__  ,      embed_dim=37  ,      has_text_modality=SCREAMING_SNAKE_CASE__  )


    def   a (			self	:	Dict  ) ->			Optional[int]:
         self.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()


    def   a (			self	:	int  ) ->			Tuple:
         return


    def   a (			self	:	int  ) ->			Any:
         lowerCAmelCase__            =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__  )


    def   a (			self	:	Any  ) ->			List[str]:
         lowerCAmelCase__            =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE__  )


    def   a (			self	:	List[Any]  ) ->			int:
         lowerCAmelCase__            =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE__  )


    def   a (			self	:	Optional[int]  ) ->			Tuple:
         lowerCAmelCase__            =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__  )


    @unittest.skip(reason="FocalNet does not use inputs_embeds"  )
    def   a (			self	:	List[Any]  ) ->			List[Any]:
         pass


    @unittest.skip(reason="FocalNet does not use feedforward chunking"  )
    def   a (			self	:	int  ) ->			Dict:
         pass


    def   a (			self	:	List[str]  ) ->			List[str]:
         lowerCAmelCase__      ,						lowerCAmelCase__            =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes[:-1]:
              lowerCAmelCase__            =					model_class(SCREAMING_SNAKE_CASE__  )
              self.assertIsInstance(model.get_input_embeddings()  ,      (nn.Module)  )
              lowerCAmelCase__            =					model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE__  ,      nn.Linear  )  )


    def   a (			self	:	List[str]  ) ->			Optional[Any]:
         lowerCAmelCase__      ,						lowerCAmelCase__            =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes[:-1]:
              lowerCAmelCase__            =					model_class(SCREAMING_SNAKE_CASE__  )
              lowerCAmelCase__            =					inspect.signature(model.forward  )
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              lowerCAmelCase__            =					[*signature.parameters.keys()]

              lowerCAmelCase__            =					["pixel_values"]
              self.assertListEqual(arg_names[:1]  ,      SCREAMING_SNAKE_CASE__  )


    def   a (			self	:	Any  ,      SCREAMING_SNAKE_CASE__	:	Optional[int]  ,      SCREAMING_SNAKE_CASE__	:	List[Any]  ,      SCREAMING_SNAKE_CASE__	:	List[Any]  ,      SCREAMING_SNAKE_CASE__	:	Union[str, Any]  ) ->			str:
         lowerCAmelCase__            =					model_class(SCREAMING_SNAKE_CASE__  )
         model.to(SCREAMING_SNAKE_CASE__  )
         model.eval()

         with torch.no_grad():
              lowerCAmelCase__            =					model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  )  )

         lowerCAmelCase__            =					outputs.hidden_states

         lowerCAmelCase__            =					getattr(
             self.model_tester  ,      "expected_num_hidden_layers"  ,      len(self.model_tester.depths  ) + 1  )
         self.assertEqual(len(SCREAMING_SNAKE_CASE__  )  ,      SCREAMING_SNAKE_CASE__  )

         # FocalNet has a different seq_length
         lowerCAmelCase__            =					(
             config.patch_size
             if isinstance(config.patch_size  ,      collections.abc.Iterable  )
             else (config.patch_size, config.patch_size)
         )

         lowerCAmelCase__            =					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

         self.assertListEqual(
             list(hidden_states[0].shape[-2:]  )  ,      [num_patches, self.model_tester.embed_dim]  ,      )

         lowerCAmelCase__            =					outputs.reshaped_hidden_states
         self.assertEqual(len(SCREAMING_SNAKE_CASE__  )  ,      SCREAMING_SNAKE_CASE__  )

         lowerCAmelCase__      ,						lowerCAmelCase__      ,						lowerCAmelCase__      ,						lowerCAmelCase__            =					reshaped_hidden_states[0].shape
         lowerCAmelCase__            =					(
             reshaped_hidden_states[0].view(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      height * width  ).permute(0  ,      2  ,      1  )
         )
         self.assertListEqual(
             list(reshaped_hidden_states.shape[-2:]  )  ,      [num_patches, self.model_tester.embed_dim]  ,      )


    def   a (			self	:	Union[str, Any]  ) ->			Optional[Any]:
         lowerCAmelCase__      ,						lowerCAmelCase__            =					self.model_tester.prepare_config_and_inputs_for_common()

         lowerCAmelCase__            =					(
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size  ,      collections.abc.Iterable  )
             else (self.model_tester.image_size, self.model_tester.image_size)
         )

         for model_class in self.all_model_classes[:-1]:
              lowerCAmelCase__            =					True
              self.check_hidden_states_output(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              lowerCAmelCase__            =					True

              self.check_hidden_states_output(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  )


    def   a (			self	:	Dict  ) ->			Any:
         lowerCAmelCase__      ,						lowerCAmelCase__            =					self.model_tester.prepare_config_and_inputs_for_common()
         lowerCAmelCase__            =					3

         lowerCAmelCase__            =					(
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size  ,      collections.abc.Iterable  )
             else (self.model_tester.image_size, self.model_tester.image_size)
         )
         lowerCAmelCase__            =					(
             config.patch_size
             if isinstance(config.patch_size  ,      collections.abc.Iterable  )
             else (config.patch_size, config.patch_size)
         )

         lowerCAmelCase__            =					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
         lowerCAmelCase__            =					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

         for model_class in self.all_model_classes[:-1]:
              lowerCAmelCase__            =					True
              self.check_hidden_states_output(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      (padded_height, padded_width)  )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              lowerCAmelCase__            =					True
              self.check_hidden_states_output(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      (padded_height, padded_width)  )


    @slow
    def   a (			self	:	Optional[int]  ) ->			Any:
         for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowerCAmelCase__            =					FocalNetModel.from_pretrained(SCREAMING_SNAKE_CASE__  )
              self.assertIsNotNone(SCREAMING_SNAKE_CASE__  )


    def   a (			self	:	str  ) ->			Optional[Any]:
         lowerCAmelCase__      ,						lowerCAmelCase__            =					self.model_tester.prepare_config_and_inputs_for_common()

         lowerCAmelCase__            =					_config_zero_init(SCREAMING_SNAKE_CASE__  )
         for model_class in self.all_model_classes:
              lowerCAmelCase__            =					model_class(config=SCREAMING_SNAKE_CASE__  )
              for name, param in model.named_parameters():
                   if "embeddings" not in name and param.requires_grad:
                        self.assertIn(
                            ((param.data.mean() * 1e9).round() / 1e9).item()  ,      [0.0, 1.0]  ,      msg=f'Parameter {name} of model {model_class} seems not properly initialized'  ,      )






@require_vision
@require_torch
class 					__lowerCamelCase			(       unittest.TestCase       ):




    """simple docstring"""

    @cached_property
    def   a (			self	:	Optional[Any]  ) ->			Optional[int]:
         # TODO update organization
         return AutoImageProcessor.from_pretrained("microsoft/focalnet-tiny"  ) if is_vision_available() else None


    @slow
    def   a (			self	:	int  ) ->			Union[str, Any]:
         lowerCAmelCase__            =					FocalNetForImageClassification.from_pretrained("microsoft/focalnet-tiny"  ).to(SCREAMING_SNAKE_CASE__  )
         lowerCAmelCase__            =					self.default_image_processor

         lowerCAmelCase__            =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
         lowerCAmelCase__            =					image_processor(images=SCREAMING_SNAKE_CASE__  ,      return_tensors="pt"  ).to(SCREAMING_SNAKE_CASE__  )

         # forward pass
         with torch.no_grad():
              lowerCAmelCase__            =					model(**SCREAMING_SNAKE_CASE__  )

         # verify the logits
         lowerCAmelCase__            =					torch.Size((1, 1_000)  )
         self.assertEqual(outputs.logits.shape  ,      SCREAMING_SNAKE_CASE__  )
         lowerCAmelCase__            =					torch.tensor([0.2_166, -0.4_368, 0.2_191]  ).to(SCREAMING_SNAKE_CASE__  )
         self.assertTrue(torch.allclose(outputs.logits[0, :3]  ,      SCREAMING_SNAKE_CASE__  ,      atol=1e-4  )  )
         self.assertTrue(outputs.logits.argmax(dim=-1  ).item()  ,      281  )






@require_torch
class 					__lowerCamelCase			(       UpperCamelCase__      ,							unittest.TestCase       ):




    """simple docstring"""

    snake_case__   = (FocalNetBackbone,) if is_torch_available() else ()
    snake_case__   = FocalNetConfig

    snake_case__   = False


    def   a (			self	:	int  ) ->			Union[str, Any]:
         lowerCAmelCase__            =					FocalNetModelTester(self  )








# coding=utf-8
# Copyright 2020 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import sys

import transformers


UpperCAmelCase__      			=						'''3'''

print('''Python version:''', sys.version)
print('''transformers version:''', transformers.__version__)

try:
			import torch

			print('''Torch version:''', torch.__version__)
			print('''Cuda available:''', torch.cuda.is_available())
			print('''Cuda version:''', torch.version.cuda)
			print('''CuDNN version:''', torch.backends.cudnn.version())
			print('''Number of GPUs available:''', torch.cuda.device_count())
			print('''NCCL version:''', torch.cuda.nccl.version())
except ImportError:
			print('''Torch version:''', None)

try:
			import deepspeed

			print('''DeepSpeed version:''', deepspeed.__version__)
except ImportError:
			print('''DeepSpeed version:''', None)

try:
			import tensorflow as tf

			print('''TensorFlow version:''', tf.__version__)
			print('''TF GPUs available:''', bool(tf.config.list_physical_devices('''GPU''')))
			print('''Number of TF GPUs available:''', len(tf.config.list_physical_devices('''GPU''')))
except ImportError:
			print('''TensorFlow version:''', None)





