


"""simple docstring"""







import inspect
import unittest

import torch
import torch.nn as nn

from accelerate.hooks import (
    AlignDevicesHook,
    ModelHook,
    SequentialHook,
    add_hook_to_module,
    attach_align_device_hook,
    remove_hook_from_module,
    remove_hook_from_submodules,
)
from accelerate.test_utils import require_multi_gpu




class 			UpperCamelCase_     (			nn.Module):

	"""simple docstring"""





	def __init__(			self      :    str       )	->     Optional[int]:
							super().__init__()
							__SCREAMING_SNAKE_CASE						       =    nn.Linear(3      ,      4       )
							__SCREAMING_SNAKE_CASE						       =    nn.BatchNormad(4       )
							__SCREAMING_SNAKE_CASE						       =    nn.Linear(4      ,      5       )




	def   UpperCAmelCase_				(			self      :    Dict      ,      UpperCAmelCase__      :    int       )	->     Union[str, Any]:
							return self.lineara(self.batchnorm(self.lineara(UpperCAmelCase__       )       )       )




class 			UpperCamelCase_     (			UpperCamelCase):

	"""simple docstring"""





	def   UpperCAmelCase_				(			self      :    Dict      ,      UpperCAmelCase__      :    List[Any]      ,      *UpperCAmelCase__      :    Any      ,      **UpperCAmelCase__      :    Optional[Any]       )	->     Tuple:
							return (args[0] + 1,) + args[1:], kwargs




class 			UpperCamelCase_     (			UpperCamelCase):

	"""simple docstring"""





	def   UpperCAmelCase_				(			self      :    Optional[int]      ,      UpperCAmelCase__      :    Any      ,      UpperCAmelCase__      :    Any       )	->     List[Any]:
							return output + 1




class 			UpperCamelCase_     (			unittest.TestCase):

	"""simple docstring"""





	def   UpperCAmelCase_				(			self      :    Any       )	->     List[str]:
							__SCREAMING_SNAKE_CASE						       =    ModelForTest()
							__SCREAMING_SNAKE_CASE						       =    ModelHook()

							add_hook_to_module(UpperCAmelCase__      ,      UpperCAmelCase__       )
							self.assertEqual(test_model._hf_hook      ,      UpperCAmelCase__       )
							self.assertTrue(hasattr(UpperCAmelCase__      ,      "_old_forward"       )       )

							# Check adding the hook did not change the name or the signature
							self.assertEqual(test_model.forward.__name__      ,      "forward"       )
							self.assertListEqual(list(inspect.signature(test_model.forward       ).parameters       )      ,      ["x"]       )

							remove_hook_from_module(UpperCAmelCase__       )
							self.assertFalse(hasattr(UpperCAmelCase__      ,      "_hf_hook"       )       )
							self.assertFalse(hasattr(UpperCAmelCase__      ,      "_old_forward"       )       )




	def   UpperCAmelCase_				(			self      :    Any       )	->     Dict:
							__SCREAMING_SNAKE_CASE						       =    ModelForTest()
							__SCREAMING_SNAKE_CASE						       =    ModelHook()

							add_hook_to_module(UpperCAmelCase__      ,      UpperCAmelCase__       )
							add_hook_to_module(UpperCAmelCase__      ,      UpperCAmelCase__      ,      append=UpperCAmelCase__       )

							self.assertEqual(isinstance(test_model._hf_hook      ,      UpperCAmelCase__       )      ,      UpperCAmelCase__       )
							self.assertEqual(len(test_model._hf_hook.hooks       )      ,      2       )
							self.assertTrue(hasattr(UpperCAmelCase__      ,      "_old_forward"       )       )

							# Check adding the hook did not change the name or the signature
							self.assertEqual(test_model.forward.__name__      ,      "forward"       )
							self.assertListEqual(list(inspect.signature(test_model.forward       ).parameters       )      ,      ["x"]       )

							remove_hook_from_module(UpperCAmelCase__       )
							self.assertFalse(hasattr(UpperCAmelCase__      ,      "_hf_hook"       )       )
							self.assertFalse(hasattr(UpperCAmelCase__      ,      "_old_forward"       )       )




	def   UpperCAmelCase_				(			self      :    List[str]       )	->     List[Any]:
							__SCREAMING_SNAKE_CASE						       =    ModelForTest()
							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       )
							__SCREAMING_SNAKE_CASE						       =    test_model(x + 1       )
							__SCREAMING_SNAKE_CASE						       =    test_model(x + 2       )

							__SCREAMING_SNAKE_CASE						       =    PreForwardHook()
							add_hook_to_module(UpperCAmelCase__      ,      UpperCAmelCase__       )
							__SCREAMING_SNAKE_CASE						       =    test_model(UpperCAmelCase__       )
							self.assertTrue(torch.allclose(UpperCAmelCase__      ,      UpperCAmelCase__      ,      atol=1E-5       )       )

							# Attaching a hook to a model when it already has one replaces, does not chain
							__SCREAMING_SNAKE_CASE						       =    PreForwardHook()
							add_hook_to_module(UpperCAmelCase__      ,      UpperCAmelCase__       )
							__SCREAMING_SNAKE_CASE						       =    test_model(UpperCAmelCase__       )
							self.assertTrue(torch.allclose(UpperCAmelCase__      ,      UpperCAmelCase__      ,      atol=1E-5       )       )

							# You need to use the sequential hook to chain two or more hooks
							__SCREAMING_SNAKE_CASE						       =    SequentialHook(PreForwardHook()      ,      PreForwardHook()       )
							add_hook_to_module(UpperCAmelCase__      ,      UpperCAmelCase__       )

							__SCREAMING_SNAKE_CASE						       =    test_model(UpperCAmelCase__       )
							assert torch.allclose(UpperCAmelCase__      ,      UpperCAmelCase__      ,      atol=1E-5       )




	def   UpperCAmelCase_				(			self      :    str       )	->     str:
							__SCREAMING_SNAKE_CASE						       =    ModelForTest()
							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       )
							__SCREAMING_SNAKE_CASE						       =    test_model(UpperCAmelCase__       )

							__SCREAMING_SNAKE_CASE						       =    PostForwardHook()
							add_hook_to_module(UpperCAmelCase__      ,      UpperCAmelCase__       )
							__SCREAMING_SNAKE_CASE						       =    test_model(UpperCAmelCase__       )
							self.assertTrue(torch.allclose(UpperCAmelCase__      ,      output + 1      ,      atol=1E-5       )       )

							# Attaching a hook to a model when it already has one replaces, does not chain
							__SCREAMING_SNAKE_CASE						       =    PostForwardHook()
							add_hook_to_module(UpperCAmelCase__      ,      UpperCAmelCase__       )
							__SCREAMING_SNAKE_CASE						       =    test_model(UpperCAmelCase__       )
							self.assertTrue(torch.allclose(UpperCAmelCase__      ,      output + 1      ,      atol=1E-5       )       )

							# You need to use the sequential hook to chain two or more hooks
							__SCREAMING_SNAKE_CASE						       =    SequentialHook(PostForwardHook()      ,      PostForwardHook()       )
							add_hook_to_module(UpperCAmelCase__      ,      UpperCAmelCase__       )

							__SCREAMING_SNAKE_CASE						       =    test_model(UpperCAmelCase__       )
							assert torch.allclose(UpperCAmelCase__      ,      output + 2      ,      atol=1E-5       )




	def   UpperCAmelCase_				(			self      :    Dict       )	->     Tuple:
							__SCREAMING_SNAKE_CASE						       =    ModelForTest()
							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       )
							__SCREAMING_SNAKE_CASE						       =    test_model(UpperCAmelCase__       )

							__SCREAMING_SNAKE_CASE						       =    PostForwardHook()
							add_hook_to_module(UpperCAmelCase__      ,      UpperCAmelCase__       )
							__SCREAMING_SNAKE_CASE						       =    test_model(UpperCAmelCase__       )
							self.assertTrue(torch.allclose(UpperCAmelCase__      ,      output + 1       )       )
							self.assertTrue(outputa.requires_grad       )

							__SCREAMING_SNAKE_CASE						       =    True
							__SCREAMING_SNAKE_CASE						       =    test_model(UpperCAmelCase__       )
							self.assertFalse(outputa.requires_grad       )




	@require_multi_gpu
	def   UpperCAmelCase_				(			self      :    Union[str, Any]       )	->     Dict:
							__SCREAMING_SNAKE_CASE						       =    ModelForTest()
							# Everything is on CPU
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )

							# This will move each submodule on different devices
							add_hook_to_module(model.lineara      ,      AlignDevicesHook(execution_device=0       )       )
							add_hook_to_module(model.batchnorm      ,      AlignDevicesHook(execution_device=0       )       )
							add_hook_to_module(model.lineara      ,      AlignDevicesHook(execution_device=1       )       )

							self.assertEqual(model.lineara.weight.device      ,      torch.device(0       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device(0       )       )
							self.assertEqual(model.batchnorm.running_mean.device      ,      torch.device(0       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device(1       )       )

							# We can still make a forward pass. The input does not need to be on any particular device
							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       )
							__SCREAMING_SNAKE_CASE						       =    model(UpperCAmelCase__       )
							self.assertEqual(output.device      ,      torch.device(1       )       )

							# We can add a general hook to put back output on same device as input.
							add_hook_to_module(UpperCAmelCase__      ,      AlignDevicesHook(io_same_device=UpperCAmelCase__       )       )
							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       ).to(0       )
							__SCREAMING_SNAKE_CASE						       =    model(UpperCAmelCase__       )
							self.assertEqual(output.device      ,      torch.device(0       )       )




	def   UpperCAmelCase_				(			self      :    Union[str, Any]       )	->     Union[str, Any]:
							__SCREAMING_SNAKE_CASE						       =    ModelForTest()

							# Everything is on CPU
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )

							# This will move each submodule on different devices
							__SCREAMING_SNAKE_CASE						       =    {"execution_device": 0 if torch.cuda.is_available() else "cpu", "offload": True}

							add_hook_to_module(model.lineara      ,      AlignDevicesHook(**UpperCAmelCase__       )       )
							add_hook_to_module(model.batchnorm      ,      AlignDevicesHook(**UpperCAmelCase__       )       )
							add_hook_to_module(model.lineara      ,      AlignDevicesHook(**UpperCAmelCase__       )       )

							# Parameters have been offloaded, so on the meta device
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							# Buffers are not included in the offload by default, so are on the execution device
							__SCREAMING_SNAKE_CASE						       =    torch.device(hook_kwargs["execution_device"]       )
							self.assertEqual(model.batchnorm.running_mean.device      ,      UpperCAmelCase__       )

							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       )
							__SCREAMING_SNAKE_CASE						       =    model(UpperCAmelCase__       )
							self.assertEqual(output.device      ,      UpperCAmelCase__       )

							# Removing hooks loads back the weights in the model.
							remove_hook_from_module(model.lineara       )
							remove_hook_from_module(model.batchnorm       )
							remove_hook_from_module(model.lineara       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )

							# Now test with buffers included in the offload
							__SCREAMING_SNAKE_CASE						       =    {
							    "execution_device": 0 if torch.cuda.is_available() else "cpu",
							    "offload": True,
							    "offload_buffers": True,
							}

							add_hook_to_module(model.lineara      ,      AlignDevicesHook(**UpperCAmelCase__       )       )
							add_hook_to_module(model.batchnorm      ,      AlignDevicesHook(**UpperCAmelCase__       )       )
							add_hook_to_module(model.lineara      ,      AlignDevicesHook(**UpperCAmelCase__       )       )

							# Parameters have been offloaded, so on the meta device, buffers included
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.batchnorm.running_mean.device      ,      torch.device("meta"       )       )

							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       )
							__SCREAMING_SNAKE_CASE						       =    model(UpperCAmelCase__       )
							self.assertEqual(output.device      ,      UpperCAmelCase__       )

							# Removing hooks loads back the weights in the model.
							remove_hook_from_module(model.lineara       )
							remove_hook_from_module(model.batchnorm       )
							remove_hook_from_module(model.lineara       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )




	def   UpperCAmelCase_				(			self      :    Optional[Any]       )	->     Optional[Any]:
							__SCREAMING_SNAKE_CASE						       =    ModelForTest()

							# Everything is on CPU
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )

							# This will move each submodule on different devices
							__SCREAMING_SNAKE_CASE						       =    0 if torch.cuda.is_available() else "cpu"
							attach_align_device_hook(UpperCAmelCase__      ,      execution_device=UpperCAmelCase__      ,      offload=UpperCAmelCase__       )

							# Parameters have been offloaded, so on the meta device
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							# Buffers are not included in the offload by default, so are on the execution device
							__SCREAMING_SNAKE_CASE						       =    torch.device(UpperCAmelCase__       )
							self.assertEqual(model.batchnorm.running_mean.device      ,      UpperCAmelCase__       )

							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       )
							__SCREAMING_SNAKE_CASE						       =    model(UpperCAmelCase__       )
							self.assertEqual(output.device      ,      UpperCAmelCase__       )

							# Removing hooks loads back the weights in the model.
							remove_hook_from_submodules(UpperCAmelCase__       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )

							# Now test with buffers included in the offload
							attach_align_device_hook(UpperCAmelCase__      ,      execution_device=UpperCAmelCase__      ,      offload=UpperCAmelCase__      ,      offload_buffers=UpperCAmelCase__       )

							# Parameters have been offloaded, so on the meta device, buffers included
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.batchnorm.running_mean.device      ,      torch.device("meta"       )       )

							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       )
							__SCREAMING_SNAKE_CASE						       =    model(UpperCAmelCase__       )
							self.assertEqual(output.device      ,      UpperCAmelCase__       )

							# Removing hooks loads back the weights in the model.
							remove_hook_from_submodules(UpperCAmelCase__       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )




	def   UpperCAmelCase_				(			self      :    int       )	->     Dict:
							__SCREAMING_SNAKE_CASE						       =    ModelForTest()

							# Everything is on CPU
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )

							# This will move each submodule on different devices
							__SCREAMING_SNAKE_CASE						       =    0 if torch.cuda.is_available() else "cpu"
							attach_align_device_hook(
							    UpperCAmelCase__      ,      execution_device=UpperCAmelCase__      ,      offload=UpperCAmelCase__      ,      weights_map=model.state_dict()       )

							# Parameters have been offloaded, so on the meta device
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							# Buffers are not included in the offload by default, so are on the execution device
							__SCREAMING_SNAKE_CASE						       =    torch.device(UpperCAmelCase__       )
							self.assertEqual(model.batchnorm.running_mean.device      ,      UpperCAmelCase__       )

							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       )
							__SCREAMING_SNAKE_CASE						       =    model(UpperCAmelCase__       )
							self.assertEqual(output.device      ,      UpperCAmelCase__       )

							# Removing hooks loads back the weights in the model.
							remove_hook_from_submodules(UpperCAmelCase__       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )

							# Now test with buffers included in the offload
							attach_align_device_hook(
							    UpperCAmelCase__      ,      execution_device=UpperCAmelCase__      ,      offload=UpperCAmelCase__      ,      weights_map=model.state_dict()      ,      offload_buffers=UpperCAmelCase__      ,      )

							# Parameters have been offloaded, so on the meta device, buffers included
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("meta"       )       )
							self.assertEqual(model.batchnorm.running_mean.device      ,      torch.device("meta"       )       )

							__SCREAMING_SNAKE_CASE						       =    torch.randn(2      ,      3       )
							__SCREAMING_SNAKE_CASE						       =    model(UpperCAmelCase__       )
							self.assertEqual(output.device      ,      UpperCAmelCase__       )

							# Removing hooks loads back the weights in the model.
							remove_hook_from_submodules(UpperCAmelCase__       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.batchnorm.weight.device      ,      torch.device("cpu"       )       )
							self.assertEqual(model.lineara.weight.device      ,      torch.device("cpu"       )       )




"""simple docstring"""







from typing import List

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a__    :							Tuple            =					logging.get_logger(__name__)

a__    :							List[Any]            =					{
    '''snap-research/efficientformer-l1-300''': (
        '''https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json'''
    ),
}




class 			UpperCamelCase_     (			UpperCamelCase):

	"""simple docstring"""





	snake_case__    :  Any    =      "efficientformer"




	def __init__(			self      :    Any      ,      UpperCAmelCase__      :    List[int] = [3, 2, 6, 4]      ,      UpperCAmelCase__      :    List[int] = [4_8, 9_6, 2_2_4, 4_4_8]      ,      UpperCAmelCase__      :    List[bool] = [True, True, True, True]      ,      UpperCAmelCase__      :    int = 4_4_8      ,      UpperCAmelCase__      :    int = 3_2      ,      UpperCAmelCase__      :    int = 4      ,      UpperCAmelCase__      :    int = 7      ,      UpperCAmelCase__      :    int = 5      ,      UpperCAmelCase__      :    int = 8      ,      UpperCAmelCase__      :    int = 4      ,      UpperCAmelCase__      :    float = 0.0      ,      UpperCAmelCase__      :    int = 1_6      ,      UpperCAmelCase__      :    int = 3      ,      UpperCAmelCase__      :    int = 3      ,      UpperCAmelCase__      :    int = 3      ,      UpperCAmelCase__      :    int = 2      ,      UpperCAmelCase__      :    int = 1      ,      UpperCAmelCase__      :    float = 0.0      ,      UpperCAmelCase__      :    int = 1      ,      UpperCAmelCase__      :    bool = True      ,      UpperCAmelCase__      :    bool = True      ,      UpperCAmelCase__      :    float = 1E-5      ,      UpperCAmelCase__      :    str = "gelu"      ,      UpperCAmelCase__      :    float = 0.02      ,      UpperCAmelCase__      :    float = 1E-12      ,      UpperCAmelCase__      :    int = 2_2_4      ,      UpperCAmelCase__      :    float = 1E-05      ,      **UpperCAmelCase__      :    Tuple      ,      )	->     None:
						super().__init__(**UpperCAmelCase__       )

						__SCREAMING_SNAKE_CASE						       =    hidden_act
						__SCREAMING_SNAKE_CASE						       =    hidden_dropout_prob
						__SCREAMING_SNAKE_CASE						       =    hidden_sizes
						__SCREAMING_SNAKE_CASE						       =    num_hidden_layers
						__SCREAMING_SNAKE_CASE						       =    num_attention_heads
						__SCREAMING_SNAKE_CASE						       =    initializer_range
						__SCREAMING_SNAKE_CASE						       =    layer_norm_eps
						__SCREAMING_SNAKE_CASE						       =    patch_size
						__SCREAMING_SNAKE_CASE						       =    num_channels
						__SCREAMING_SNAKE_CASE						       =    depths
						__SCREAMING_SNAKE_CASE						       =    mlp_expansion_ratio
						__SCREAMING_SNAKE_CASE						       =    downsamples
						__SCREAMING_SNAKE_CASE						       =    dim
						__SCREAMING_SNAKE_CASE						       =    key_dim
						__SCREAMING_SNAKE_CASE						       =    attention_ratio
						__SCREAMING_SNAKE_CASE						       =    resolution
						__SCREAMING_SNAKE_CASE						       =    pool_size
						__SCREAMING_SNAKE_CASE						       =    downsample_patch_size
						__SCREAMING_SNAKE_CASE						       =    downsample_stride
						__SCREAMING_SNAKE_CASE						       =    downsample_pad
						__SCREAMING_SNAKE_CASE						       =    drop_path_rate
						__SCREAMING_SNAKE_CASE						       =    num_metaad_blocks
						__SCREAMING_SNAKE_CASE						       =    distillation
						__SCREAMING_SNAKE_CASE						       =    use_layer_scale
						__SCREAMING_SNAKE_CASE						       =    layer_scale_init_value
						__SCREAMING_SNAKE_CASE						       =    image_size
						__SCREAMING_SNAKE_CASE						       =    batch_norm_eps
