

'''simple docstring'''


import re
import tempfile
from pathlib import Path

import pytest
import yaml

from datasets.utils.readme import ReadMe


# @pytest.fixture
# def example_yaml_structure():

lowerCAmelCase__										= yaml.safe_load(
    "\\nname: \"\"\nallow_empty: false\nallow_empty_text: true\nsubsections:\n  - name: \"Dataset Card for X\" # First-level markdown heading\n    allow_empty: false\n    allow_empty_text: true\n    subsections:\n      - name: \"Table of Contents\"\n        allow_empty: false\n        allow_empty_text: false\n        subsections: null\n      - name: \"Dataset Description\"\n        allow_empty: false\n        allow_empty_text: false\n        subsections:\n          - name: \"Dataset Summary\"\n            allow_empty: false\n            allow_empty_text: false\n            subsections: null\n          - name: \"Supported Tasks and Leaderboards\"\n            allow_empty: true\n            allow_empty_text: true\n            subsections: null\n          - name: Languages\n            allow_empty: false\n            allow_empty_text: true\n            subsections: null\n"
)


lowerCAmelCase__										= {
    "name": "root",
    "text": "",
    "is_empty_text": True,
    "subsections": [
        {
            "name": "Dataset Card for My Dataset",
            "text": "",
            "is_empty_text": True,
            "subsections": [
                {"name": "Table of Contents", "text": "Some text here.", "is_empty_text": False, "subsections": []},
                {
                    "name": "Dataset Description",
                    "text": "Some text here.",
                    "is_empty_text": False,
                    "subsections": [
                        {
                            "name": "Dataset Summary",
                            "text": "Some text here.",
                            "is_empty_text": False,
                            "subsections": [],
                        },
                        {
                            "name": "Supported Tasks and Leaderboards",
                            "text": "",
                            "is_empty_text": True,
                            "subsections": [],
                        },
                        {"name": "Languages", "text": "Language Text", "is_empty_text": False, "subsections": []},
                    ],
                },
            ],
        }
    ],
}


lowerCAmelCase__										= "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"


lowerCAmelCase__										= "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n#### Extra Ignored Subsection\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

lowerCAmelCase__										= {
    "name": "root",
    "text": "",
    "is_empty_text": True,
    "subsections": [
        {
            "name": "Dataset Card for My Dataset",
            "text": "",
            "is_empty_text": True,
            "subsections": [
                {"name": "Table of Contents", "text": "Some text here.", "is_empty_text": False, "subsections": []},
                {
                    "name": "Dataset Description",
                    "text": "Some text here.",
                    "is_empty_text": False,
                    "subsections": [
                        {
                            "name": "Dataset Summary",
                            "text": "Some text here.",
                            "is_empty_text": False,
                            "subsections": [
                                {
                                    "name": "Extra Ignored Subsection",
                                    "text": "",
                                    "is_empty_text": True,
                                    "subsections": [],
                                }
                            ],
                        },
                        {
                            "name": "Supported Tasks and Leaderboards",
                            "text": "",
                            "is_empty_text": True,
                            "subsections": [],
                        },
                        {"name": "Languages", "text": "Language Text", "is_empty_text": False, "subsections": []},
                    ],
                },
            ],
        }
    ],
}

lowerCAmelCase__										= "\\n---\n---\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

lowerCAmelCase__										= (
    "The following issues were found for the README at `{path}`:\n-\tEmpty YAML markers are present in the README."
)

lowerCAmelCase__										= "\\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

lowerCAmelCase__										= (
    "The following issues were found for the README at `{path}`:\n-\tNo YAML markers are present in the README."
)

lowerCAmelCase__										= "\\n---\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

lowerCAmelCase__										= "The following issues were found for the README at `{path}`:\n-\tOnly the start of YAML tags present in the README."

lowerCAmelCase__										= "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"
lowerCAmelCase__										= "The following issues were found for the README at `{path}`:\n-\tExpected some content in section `Dataset Summary` but it is empty.\n-\tExpected some text in section `Dataset Summary` but it is empty (text in subsections are ignored)."


lowerCAmelCase__										= "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n"
lowerCAmelCase__										= "The following issues were found for the README at `{path}`:\n-\tExpected some content in section `Dataset Card for My Dataset` but it is empty.\n-\tSection `Dataset Card for My Dataset` expected the following subsections: `Table of Contents`, `Dataset Description`. Found 'None'."

lowerCAmelCase__										= "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Languages\nLanguage Text\n"

lowerCAmelCase__										= "The following issues were found for the README at `{path}`:\n-\tSection `Dataset Description` is missing subsection: `Supported Tasks and Leaderboards`."


lowerCAmelCase__										= "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\n"

lowerCAmelCase__										= "The following issues were found for the README at `{path}`:\n-\tExpected some content in section `Languages` but it is empty."

lowerCAmelCase__										= "\\n---\nlanguage:\n- zh\n- en\n---\n\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"
lowerCAmelCase__										= "The following issues were found for the README at `{path}`:\n-\tThe README has no first-level headings. One heading is expected. Skipping further validation for this README."

lowerCAmelCase__										= "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n# Dataset Card My Dataset\n"

lowerCAmelCase__										= "The following issues were found for the README at `{path}`:\n-\tThe README has several first-level headings: `Dataset Card for My Dataset`, `Dataset Card My Dataset`. Only one heading is expected. Skipping further validation for this README."

lowerCAmelCase__										= "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

lowerCAmelCase__										= "The following issues were found for the README at `{path}`:\n-\tNo first-level heading starting with `Dataset Card for` found in README. Skipping further validation for this README."

lowerCAmelCase__										= ""

lowerCAmelCase__										= "The following issues were found for the README at `{path}`:\n-\tThe README has no first-level headings. One heading is expected. Skipping further validation for this README.\n-\tNo YAML markers are present in the README."

lowerCAmelCase__										= "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

lowerCAmelCase__										= "The following issues were found while parsing the README at `{path}`:\n-\tMultiple sections with the same heading `Dataset Card for My Dataset` have been found. Please keep only one of these sections."







@pytest.mark.parametrize(
    'readme_md, expected_dict'   ,[
        (README_CORRECT, CORRECT_DICT),
        (README_CORRECT_FOUR_LEVEL, CORRECT_DICT_FOUR_LEVEL),
    ]   ,)
def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,UpperCamelCase  )    ->    int:
	assert ReadMe.from_string(UpperCamelCase   ,UpperCamelCase  ).to_dict() == expected_dict







@pytest.mark.parametrize(
    'readme_md, expected_error'   ,[
        (README_NO_YAML, EXPECTED_ERROR_README_NO_YAML),
        (README_EMPTY_YAML, EXPECTED_ERROR_README_EMPTY_YAML),
        (README_INCORRECT_YAML, EXPECTED_ERROR_README_INCORRECT_YAML),
        (README_EMPTY, EXPECTED_ERROR_README_EMPTY),
        (README_NONE_SUBSECTION, EXPECTED_ERROR_README_NONE_SUBSECTION),
        (README_MISSING_FIRST_LEVEL, EXPECTED_ERROR_README_MISSING_FIRST_LEVEL),
        (README_MISSING_SUBSECTION, EXPECTED_ERROR_README_MISSING_SUBSECTION),
        (README_MISSING_TEXT, EXPECTED_ERROR_README_MISSING_TEXT),
        (README_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_WRONG_FIRST_LEVEL),
        (README_MULTIPLE_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_MULTIPLE_WRONG_FIRST_LEVEL),
        (README_MISSING_CONTENT, EXPECTED_ERROR_README_MISSING_CONTENT),
    ]   ,)
def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,UpperCamelCase  )    ->    Union[str, Any]:
	with pytest.raises(UpperCamelCase   ,match=re.escape(expected_error.format(path='root'  )  )  ):
		UpperCAmelCase_		:      int       	=					ReadMe.from_string(UpperCamelCase   ,UpperCamelCase  )
		readme.validate()







@pytest.mark.parametrize(
    'readme_md, expected_error'   ,[
        (README_MULTIPLE_SAME_HEADING_1, EXPECTED_ERROR_README_MULTIPLE_SAME_HEADING_1),
    ]   ,)
def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,UpperCamelCase  )    ->    List[str]:
	with pytest.raises(UpperCamelCase   ,match=re.escape(expected_error.format(path='root'  )  )  ):
		ReadMe.from_string(UpperCamelCase   ,UpperCamelCase  )







@pytest.mark.parametrize(
    'readme_md,'   ,[
        (README_MULTIPLE_SAME_HEADING_1),
    ]   ,)
def 						SCREAMING_SNAKE_CASE(  UpperCamelCase  )    ->    List[str]:
	ReadMe.from_string(UpperCamelCase   ,UpperCamelCase   ,suppress_parsing_errors=UpperCamelCase  )







@pytest.mark.parametrize(
    'readme_md, expected_dict'   ,[
        (README_CORRECT, CORRECT_DICT),
        (README_CORRECT_FOUR_LEVEL, CORRECT_DICT_FOUR_LEVEL),
    ]   ,)
def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,UpperCamelCase  )    ->    Dict:
	with tempfile.TemporaryDirectory() as tmp_dir:
		UpperCAmelCase_		:      Dict       	=					Path(UpperCamelCase  ) / 'README.md'
		with open(UpperCamelCase   ,'w+'  ) as readme_file:
			readme_file.write(UpperCamelCase  )
		UpperCAmelCase_		:      List[str]       	=					ReadMe.from_readme(UpperCamelCase   ,UpperCamelCase  ).to_dict()
		assert out["name"] == path
		assert out["text"] == ""
		assert out["is_empty_text"]
		assert out["subsections"] == expected_dict["subsections"]







@pytest.mark.parametrize(
    'readme_md, expected_error'   ,[
        (README_NO_YAML, EXPECTED_ERROR_README_NO_YAML),
        (README_EMPTY_YAML, EXPECTED_ERROR_README_EMPTY_YAML),
        (README_INCORRECT_YAML, EXPECTED_ERROR_README_INCORRECT_YAML),
        (README_EMPTY, EXPECTED_ERROR_README_EMPTY),
        (README_NONE_SUBSECTION, EXPECTED_ERROR_README_NONE_SUBSECTION),
        (README_MISSING_FIRST_LEVEL, EXPECTED_ERROR_README_MISSING_FIRST_LEVEL),
        (README_MISSING_SUBSECTION, EXPECTED_ERROR_README_MISSING_SUBSECTION),
        (README_MISSING_TEXT, EXPECTED_ERROR_README_MISSING_TEXT),
        (README_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_WRONG_FIRST_LEVEL),
        (README_MULTIPLE_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_MULTIPLE_WRONG_FIRST_LEVEL),
        (README_MISSING_CONTENT, EXPECTED_ERROR_README_MISSING_CONTENT),
    ]   ,)
def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,UpperCamelCase  )    ->    Union[str, Any]:
	with tempfile.TemporaryDirectory() as tmp_dir:
		UpperCAmelCase_		:      Any       	=					Path(UpperCamelCase  ) / 'README.md'
		with open(UpperCamelCase   ,'w+'  ) as readme_file:
			readme_file.write(UpperCamelCase  )
		UpperCAmelCase_		:      List[Any]       	=					expected_error.format(path=UpperCamelCase  )
		with pytest.raises(UpperCamelCase   ,match=re.escape(UpperCamelCase  )  ):
			UpperCAmelCase_		:      str       	=					ReadMe.from_readme(UpperCamelCase   ,UpperCamelCase  )
			readme.validate()







@pytest.mark.parametrize(
    'readme_md, expected_error'   ,[
        (README_MULTIPLE_SAME_HEADING_1, EXPECTED_ERROR_README_MULTIPLE_SAME_HEADING_1),
    ]   ,)
def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,UpperCamelCase  )    ->    Optional[Any]:
	with tempfile.TemporaryDirectory() as tmp_dir:
		UpperCAmelCase_		:      Any       	=					Path(UpperCamelCase  ) / 'README.md'
		with open(UpperCamelCase   ,'w+'  ) as readme_file:
			readme_file.write(UpperCamelCase  )
		UpperCAmelCase_		:      List[str]       	=					expected_error.format(path=UpperCamelCase  )
		with pytest.raises(UpperCamelCase   ,match=re.escape(UpperCamelCase  )  ):
			ReadMe.from_readme(UpperCamelCase   ,UpperCamelCase  )







@pytest.mark.parametrize(
    'readme_md,'   ,[
        (README_MULTIPLE_SAME_HEADING_1),
    ]   ,)
def 						SCREAMING_SNAKE_CASE(  UpperCamelCase  )    ->    Any:
	with tempfile.TemporaryDirectory() as tmp_dir:
		UpperCAmelCase_		:      Dict       	=					Path(UpperCamelCase  ) / 'README.md'
		with open(UpperCamelCase   ,'w+'  ) as readme_file:
			readme_file.write(UpperCamelCase  )
		ReadMe.from_readme(UpperCamelCase   ,UpperCamelCase   ,suppress_parsing_errors=UpperCamelCase  )









'''simple docstring'''


from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_outputs import (
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import logging
from .configuration_regnet import RegNetConfig


lowerCAmelCase__										= logging.get_logger(__name__)

# General docstring
lowerCAmelCase__										= "RegNetConfig"

# Base docstring
lowerCAmelCase__										= "facebook/regnet-y-040"
lowerCAmelCase__										= [1, 1088, 7, 7]

# Image classification docstring
lowerCAmelCase__										= "facebook/regnet-y-040"
lowerCAmelCase__										= "tabby, tabby cat"

lowerCAmelCase__										= [
    "facebook/regnet-y-040",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case = 3    ,			_snake_case = 1    ,			_snake_case = 1    ,			_snake_case = "relu"    ,			)							->				int:
								super().__init__()
								UpperCAmelCase_		:      str       	=					nn.Convad(
								    _snake_case    ,			_snake_case    ,			kernel_size=_snake_case    ,			stride=_snake_case    ,			padding=kernel_size // 2    ,			groups=_snake_case    ,			bias=_snake_case    ,			)
								UpperCAmelCase_		:      List[Any]       	=					nn.BatchNormad(_snake_case)
								UpperCAmelCase_		:      Tuple       	=					ACTaFN[activation] if activation is not None else nn.Identity()





							def 						_snake_case							(			self    ,			_snake_case)							->				Tuple:
								UpperCAmelCase_		:      Optional[int]       	=					self.convolution(_snake_case)
								UpperCAmelCase_		:      int       	=					self.normalization(_snake_case)
								UpperCAmelCase_		:      Optional[int]       	=					self.activation(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case)							->				List[Any]:
								super().__init__()
								UpperCAmelCase_		:      Tuple       	=					RegNetConvLayer(
								    config.num_channels    ,			config.embedding_size    ,			kernel_size=3    ,			stride=2    ,			activation=config.hidden_act)
								UpperCAmelCase_		:      Optional[Any]       	=					config.num_channels





							def 						_snake_case							(			self    ,			_snake_case)							->				Dict:
								UpperCAmelCase_		:      List[Any]       	=					pixel_values.shape[1]
								if num_channels != self.num_channels:
									raise ValueError(
									    'Make sure that the channel dimension of the pixel values match with the one set in the configuration.')
								UpperCAmelCase_		:      Any       	=					self.embedder(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case = 2)							->				Optional[Any]:
								super().__init__()
								UpperCAmelCase_		:      Any       	=					nn.Convad(_snake_case    ,			_snake_case    ,			kernel_size=1    ,			stride=_snake_case    ,			bias=_snake_case)
								UpperCAmelCase_		:      Optional[Any]       	=					nn.BatchNormad(_snake_case)





							def 						_snake_case							(			self    ,			_snake_case)							->				Tensor:
								UpperCAmelCase_		:      Optional[Any]       	=					self.convolution(_snake_case)
								UpperCAmelCase_		:      Dict       	=					self.normalization(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case    ,			_snake_case)							->				Any:
								super().__init__()

								UpperCAmelCase_		:      Tuple       	=					nn.AdaptiveAvgPoolad((1, 1))
								UpperCAmelCase_		:      int       	=					nn.Sequential(
								    nn.Convad(_snake_case    ,			_snake_case    ,			kernel_size=1)    ,			nn.ReLU()    ,			nn.Convad(_snake_case    ,			_snake_case    ,			kernel_size=1)    ,			nn.Sigmoid()    ,			)





							def 						_snake_case							(			self    ,			_snake_case)							->				Any:
								# b c h w -> b c 1 1
								UpperCAmelCase_		:      Union[str, Any]       	=					self.pooler(_snake_case)
								UpperCAmelCase_		:      Any       	=					self.attention(_snake_case)
								UpperCAmelCase_		:      Optional[Any]       	=					hidden_state * attention
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case    ,			_snake_case = 1)							->				str:
								super().__init__()
								UpperCAmelCase_		:      Optional[Any]       	=					in_channels != out_channels or stride != 1
								UpperCAmelCase_		:      Any       	=					max(1    ,			out_channels // config.groups_width)
								UpperCAmelCase_		:      str       	=					(
								    RegNetShortCut(_snake_case    ,			_snake_case    ,			stride=_snake_case) if should_apply_shortcut else nn.Identity()
								)
								UpperCAmelCase_		:      Optional[int]       	=					nn.Sequential(
								    RegNetConvLayer(_snake_case    ,			_snake_case    ,			kernel_size=1    ,			activation=config.hidden_act)    ,			RegNetConvLayer(_snake_case    ,			_snake_case    ,			stride=_snake_case    ,			groups=_snake_case    ,			activation=config.hidden_act)    ,			RegNetConvLayer(_snake_case    ,			_snake_case    ,			kernel_size=1    ,			activation=_snake_case)    ,			)
								UpperCAmelCase_		:      int       	=					ACTaFN[config.hidden_act]





							def 						_snake_case							(			self    ,			_snake_case)							->				Union[str, Any]:
								UpperCAmelCase_		:      str       	=					hidden_state
								UpperCAmelCase_		:      List[Any]       	=					self.layer(_snake_case)
								UpperCAmelCase_		:      Dict       	=					self.shortcut(_snake_case)
								hidden_state += residual
								UpperCAmelCase_		:      Any       	=					self.activation(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case    ,			_snake_case = 1)							->				int:
								super().__init__()
								UpperCAmelCase_		:      List[Any]       	=					in_channels != out_channels or stride != 1
								UpperCAmelCase_		:      Optional[Any]       	=					max(1    ,			out_channels // config.groups_width)
								UpperCAmelCase_		:      Optional[int]       	=					(
								    RegNetShortCut(_snake_case    ,			_snake_case    ,			stride=_snake_case) if should_apply_shortcut else nn.Identity()
								)
								UpperCAmelCase_		:      Optional[Any]       	=					nn.Sequential(
								    RegNetConvLayer(_snake_case    ,			_snake_case    ,			kernel_size=1    ,			activation=config.hidden_act)    ,			RegNetConvLayer(_snake_case    ,			_snake_case    ,			stride=_snake_case    ,			groups=_snake_case    ,			activation=config.hidden_act)    ,			RegNetSELayer(_snake_case    ,			reduced_channels=int(round(in_channels / 4)))    ,			RegNetConvLayer(_snake_case    ,			_snake_case    ,			kernel_size=1    ,			activation=_snake_case)    ,			)
								UpperCAmelCase_		:      Any       	=					ACTaFN[config.hidden_act]





							def 						_snake_case							(			self    ,			_snake_case)							->				Union[str, Any]:
								UpperCAmelCase_		:      List[str]       	=					hidden_state
								UpperCAmelCase_		:      int       	=					self.layer(_snake_case)
								UpperCAmelCase_		:      Any       	=					self.shortcut(_snake_case)
								hidden_state += residual
								UpperCAmelCase_		:      Any       	=					self.activation(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case    ,			_snake_case = 2    ,			_snake_case = 2    ,			)							->				Optional[int]:
								super().__init__()

								UpperCAmelCase_		:      str       	=					RegNetXLayer if config.layer_type == 'x' else RegNetYLayer

								UpperCAmelCase_		:      Dict       	=					nn.Sequential(
								    # downsampling is done in the first layer with stride of 2
								    layer(
								        _snake_case    ,			_snake_case    ,			_snake_case    ,			stride=_snake_case    ,			)    ,			*[layer(_snake_case    ,			_snake_case    ,			_snake_case) for _ in range(depth - 1)]    ,			)





							def 						_snake_case							(			self    ,			_snake_case)							->				Dict:
								UpperCAmelCase_		:      Optional[Any]       	=					self.layers(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case)							->				List[Any]:
								super().__init__()
								UpperCAmelCase_		:      List[str]       	=					nn.ModuleList([])
								# based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
								self.stages.append(
								    RegNetStage(
								        _snake_case    ,			config.embedding_size    ,			config.hidden_sizes[0]    ,			stride=2 if config.downsample_in_first_stage else 1    ,			depth=config.depths[0]    ,			))
								UpperCAmelCase_		:      Dict       	=					zip(config.hidden_sizes    ,			config.hidden_sizes[1:])
								for (in_channels, out_channels), depth in zip(_snake_case    ,			config.depths[1:]):
									self.stages.append(RegNetStage(_snake_case    ,			_snake_case    ,			_snake_case    ,			depth=_snake_case))





							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case = False    ,			_snake_case = True)							->				BaseModelOutputWithNoAttention:
								UpperCAmelCase_		:      List[Any]       	=					() if output_hidden_states else None

								for stage_module in self.stages:
									if output_hidden_states:
										UpperCAmelCase_		:      int       	=					hidden_states + (hidden_state,)

									UpperCAmelCase_		:      Tuple       	=					stage_module(_snake_case)

								if output_hidden_states:
									UpperCAmelCase_		:      Union[str, Any]       	=					hidden_states + (hidden_state,)

								if not return_dict:
									return tuple(v for v in [hidden_state, hidden_states] if v is not None)

								return BaseModelOutputWithNoAttention(last_hidden_state=_snake_case    ,			hidden_states=_snake_case)



class 					lowercase						(  a_ ):
							_lowerCamelCase		:      str=   RegNetConfig
							_lowerCamelCase		:      Optional[int]=   "regnet"
							_lowerCamelCase		:      Union[str, Any]=   "pixel_values"
							_lowerCamelCase		:      List[str]=   True


							def 						_snake_case							(			self    ,			_snake_case)							->				List[Any]:
								if isinstance(_snake_case    ,			nn.Convad):
									nn.init.kaiming_normal_(module.weight    ,			mode='fan_out'    ,			nonlinearity='relu')
								elif isinstance(_snake_case    ,			(nn.BatchNormad, nn.GroupNorm)):
									nn.init.constant_(module.weight    ,			1)
									nn.init.constant_(module.bias    ,			0)





							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case=False)							->				List[Any]:
								if isinstance(_snake_case    ,			_snake_case):
									UpperCAmelCase_		:      str       	=					value


lowerCAmelCase__										= r"\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n"

lowerCAmelCase__										= r"\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.\n"



@add_start_docstrings(
    "The bare RegNet model outputting raw features without any specific head on top.",					a_,					)
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class 					lowercase						(  a_ ):


							def __init__(			self    ,			_snake_case)							->				List[str]:
								super().__init__(_snake_case)
								UpperCAmelCase_		:      str       	=					config
								UpperCAmelCase_		:      Optional[int]       	=					RegNetEmbeddings(_snake_case)
								UpperCAmelCase_		:      int       	=					RegNetEncoder(_snake_case)
								UpperCAmelCase_		:      Any       	=					nn.AdaptiveAvgPoolad((1, 1))
								# Initialize weights and apply final processing
								self.post_init()





							@add_start_docstrings_to_model_forward(_snake_case)
							@add_code_sample_docstrings(
							    checkpoint=_CHECKPOINT_FOR_DOC    ,			output_type=_snake_case    ,			config_class=_CONFIG_FOR_DOC    ,			modality='vision'    ,			expected_output=_EXPECTED_OUTPUT_SHAPE    ,			)
							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case = None    ,			_snake_case = None)							->				BaseModelOutputWithPoolingAndNoAttention:
								UpperCAmelCase_		:      List[Any]       	=					(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								UpperCAmelCase_		:      Optional[Any]       	=					return_dict if return_dict is not None else self.config.use_return_dict

								UpperCAmelCase_		:      int       	=					self.embedder(_snake_case)

								UpperCAmelCase_		:      str       	=					self.encoder(
								    _snake_case    ,			output_hidden_states=_snake_case    ,			return_dict=_snake_case)

								UpperCAmelCase_		:      List[Any]       	=					encoder_outputs[0]

								UpperCAmelCase_		:      str       	=					self.pooler(_snake_case)

								if not return_dict:
									return (last_hidden_state, pooled_output) + encoder_outputs[1:]

								return BaseModelOutputWithPoolingAndNoAttention(
								    last_hidden_state=_snake_case    ,			pooler_output=_snake_case    ,			hidden_states=encoder_outputs.hidden_states    ,			)



@add_start_docstrings(
    "\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    ",					a_,					)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class 					lowercase						(  a_ ):


							def __init__(			self    ,			_snake_case)							->				Union[str, Any]:
								super().__init__(_snake_case)
								UpperCAmelCase_		:      List[str]       	=					config.num_labels
								UpperCAmelCase_		:      Optional[int]       	=					RegNetModel(_snake_case)
								# classification head
								UpperCAmelCase_		:      Optional[Any]       	=					nn.Sequential(
								    nn.Flatten()    ,			nn.Linear(config.hidden_sizes[-1]    ,			config.num_labels) if config.num_labels > 0 else nn.Identity()    ,			)
								# initialize weights and apply final processing
								self.post_init()





							@add_start_docstrings_to_model_forward(_snake_case)
							@add_code_sample_docstrings(
							    checkpoint=_IMAGE_CLASS_CHECKPOINT    ,			output_type=_snake_case    ,			config_class=_CONFIG_FOR_DOC    ,			expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT    ,			)
							def 						_snake_case							(			self    ,			_snake_case = None    ,			_snake_case = None    ,			_snake_case = None    ,			_snake_case = None    ,			)							->				ImageClassifierOutputWithNoAttention:
								UpperCAmelCase_		:      str       	=					return_dict if return_dict is not None else self.config.use_return_dict

								UpperCAmelCase_		:      Optional[Any]       	=					self.regnet(_snake_case    ,			output_hidden_states=_snake_case    ,			return_dict=_snake_case)

								UpperCAmelCase_		:      Dict       	=					outputs.pooler_output if return_dict else outputs[1]

								UpperCAmelCase_		:      int       	=					self.classifier(_snake_case)

								UpperCAmelCase_		:      List[Any]       	=					None

								if labels is not None:
									if self.config.problem_type is None:
										if self.num_labels == 1:
											UpperCAmelCase_		:      Optional[int]       	=					'regression'
										elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
											UpperCAmelCase_		:      Union[str, Any]       	=					'single_label_classification'
										else:
											UpperCAmelCase_		:      Tuple       	=					'multi_label_classification'
									if self.config.problem_type == "regression":
										UpperCAmelCase_		:      int       	=					MSELoss()
										if self.num_labels == 1:
											UpperCAmelCase_		:      Dict       	=					loss_fct(logits.squeeze()    ,			labels.squeeze())
										else:
											UpperCAmelCase_		:      Union[str, Any]       	=					loss_fct(_snake_case    ,			_snake_case)
									elif self.config.problem_type == "single_label_classification":
										UpperCAmelCase_		:      Optional[int]       	=					CrossEntropyLoss()
										UpperCAmelCase_		:      Union[str, Any]       	=					loss_fct(logits.view(-1    ,			self.num_labels)    ,			labels.view(-1))
									elif self.config.problem_type == "multi_label_classification":
										UpperCAmelCase_		:      int       	=					BCEWithLogitsLoss()
										UpperCAmelCase_		:      Tuple       	=					loss_fct(_snake_case    ,			_snake_case)

								if not return_dict:
									UpperCAmelCase_		:      Union[str, Any]       	=					(logits,) + outputs[2:]
									return (loss,) + output if loss is not None else output

								return ImageClassifierOutputWithNoAttention(loss=_snake_case    ,			logits=_snake_case    ,			hidden_states=outputs.hidden_states)






