827 lines
30 KiB
Python
827 lines
30 KiB
Python
# Copyright 2022 The HuggingFace Team. All rights reserved.
|
|
#
|
|
# 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.
|
|
import os
|
|
import shutil
|
|
import tempfile
|
|
import textwrap
|
|
import unittest
|
|
from datetime import date
|
|
from pathlib import Path
|
|
|
|
import transformers.commands.add_new_model_like
|
|
from transformers.commands.add_new_model_like import ModelInfos, create_new_model_like
|
|
from transformers.testing_utils import require_torch
|
|
|
|
|
|
REPO_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
|
|
MODELS_TO_COPY = ("auto", "llama", "phi4_multimodal")
|
|
CURRENT_YEAR = date.today().year
|
|
|
|
|
|
@require_torch
|
|
class TestAddNewModelLike(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
"""
|
|
Create a temporary repo with the same structure as Transformers, with just 2 models.
|
|
"""
|
|
cls.FAKE_REPO = tempfile.TemporaryDirectory().name
|
|
os.makedirs(os.path.join(cls.FAKE_REPO, "src", "transformers", "models"), exist_ok=True)
|
|
os.makedirs(os.path.join(cls.FAKE_REPO, "tests", "models"), exist_ok=True)
|
|
os.makedirs(os.path.join(cls.FAKE_REPO, "docs", "source", "en", "model_doc"), exist_ok=True)
|
|
|
|
# We need to copy the utils to run the cleanup commands
|
|
utils_src = os.path.join(REPO_PATH, "utils")
|
|
shutil.copytree(utils_src, utils_src.replace(REPO_PATH, cls.FAKE_REPO))
|
|
# Copy the __init__ files
|
|
model_init = os.path.join(REPO_PATH, "src", "transformers", "models", "__init__.py")
|
|
shutil.copy(model_init, model_init.replace(REPO_PATH, cls.FAKE_REPO))
|
|
doc_toc = os.path.join(REPO_PATH, "docs", "source", "en", "_toctree.yml")
|
|
shutil.copy(doc_toc, doc_toc.replace(REPO_PATH, cls.FAKE_REPO))
|
|
# We need the pyproject for ruff as well
|
|
pyproject = os.path.join(REPO_PATH, "pyproject.toml")
|
|
shutil.copy(pyproject, pyproject.replace(REPO_PATH, cls.FAKE_REPO))
|
|
# Copy over all the specific model files
|
|
for model in MODELS_TO_COPY:
|
|
model_src = os.path.join(REPO_PATH, "src", "transformers", "models", model)
|
|
shutil.copytree(model_src, model_src.replace(REPO_PATH, cls.FAKE_REPO))
|
|
|
|
test_src = os.path.join(REPO_PATH, "tests", "models", model)
|
|
shutil.copytree(test_src, test_src.replace(REPO_PATH, cls.FAKE_REPO))
|
|
|
|
if model != "auto":
|
|
doc_src = os.path.join(REPO_PATH, "docs", "source", "en", "model_doc", f"{model}.md")
|
|
shutil.copy(doc_src, doc_src.replace(REPO_PATH, cls.FAKE_REPO))
|
|
|
|
# Replace the globals
|
|
cls.ORIGINAL_REPO = transformers.commands.add_new_model_like.REPO_PATH
|
|
cls.ORIGINAL_TRANSFORMERS_REPO = transformers.commands.add_new_model_like.TRANSFORMERS_PATH
|
|
transformers.commands.add_new_model_like.REPO_PATH = Path(cls.FAKE_REPO)
|
|
transformers.commands.add_new_model_like.TRANSFORMERS_PATH = Path(cls.FAKE_REPO) / "src" / "transformers"
|
|
|
|
# For convenience
|
|
cls.MODEL_PATH = os.path.join(cls.FAKE_REPO, "src", "transformers", "models")
|
|
cls.TESTS_MODEL_PATH = os.path.join(cls.FAKE_REPO, "tests", "models")
|
|
cls.DOC_PATH = os.path.join(cls.FAKE_REPO, "docs", "source", "en")
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
transformers.commands.add_new_model_like.REPO_PATH = cls.ORIGINAL_REPO
|
|
transformers.commands.add_new_model_like.TRANSFORMERS_PATH = cls.ORIGINAL_TRANSFORMERS_REPO
|
|
del cls.FAKE_REPO
|
|
|
|
def assertFileIsEqual(self, text: str, filepath: str):
|
|
with open(filepath, "r") as f:
|
|
file_text = f.read()
|
|
self.assertEqual(file_text.strip(), text.strip())
|
|
|
|
def assertInFile(self, text: str, filepath: str):
|
|
with open(filepath, "r") as f:
|
|
file_text = f.read()
|
|
self.assertTrue(text in file_text)
|
|
|
|
def test_llama_without_tokenizers(self):
|
|
# This is the structure without adding the tokenizers
|
|
filenames_to_add = (
|
|
("configuration_llama.py", True),
|
|
("modeling_llama.py", True),
|
|
("tokenization_llama.py", False),
|
|
("tokenization_llama_fast.py", False),
|
|
("image_processing_llama.py", False),
|
|
("image_processing_llama_fast.py", False),
|
|
("video_processing_llama.py", False),
|
|
("feature_extraction_llama.py", False),
|
|
("processing_llama.py", False),
|
|
)
|
|
# Run the command
|
|
create_new_model_like(
|
|
old_model_infos=ModelInfos("llama"),
|
|
new_lowercase_name="my_test",
|
|
new_model_paper_name="MyTest",
|
|
filenames_to_add=filenames_to_add,
|
|
create_fast_image_processor=False,
|
|
)
|
|
|
|
# First assert that all files were created correctly
|
|
model_repo = os.path.join(self.MODEL_PATH, "my_test")
|
|
tests_repo = os.path.join(self.TESTS_MODEL_PATH, "my_test")
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "modular_my_test.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "modeling_my_test.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "configuration_my_test.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "__init__.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(self.DOC_PATH, "model_doc", "my_test.md")))
|
|
self.assertTrue(os.path.isfile(os.path.join(tests_repo, "__init__.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(tests_repo, "test_modeling_my_test.py")))
|
|
|
|
# Now assert the correct imports/auto mappings/toctree were added
|
|
self.assertInFile(
|
|
"from .my_test import *\n",
|
|
os.path.join(self.MODEL_PATH, "__init__.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test", "MyTestConfig"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "configuration_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test", "MyTest"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "configuration_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test", "MyTestModel"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "modeling_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test", "MyTestForCausalLM"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "modeling_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test", "MyTestForSequenceClassification"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "modeling_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test", "MyTestForQuestionAnswering"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "modeling_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test", "MyTestForTokenClassification"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "modeling_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
"- local: model_doc/my_test\n title: MyTest\n",
|
|
os.path.join(self.DOC_PATH, "_toctree.yml"),
|
|
)
|
|
|
|
# Check some exact file creation. For model definition, only check modular as modeling/config/etc... are created
|
|
# directly from it
|
|
EXPECTED_MODULAR = textwrap.dedent(
|
|
f"""
|
|
# coding=utf-8
|
|
# Copyright {CURRENT_YEAR} the HuggingFace Team. All rights reserved.
|
|
#
|
|
# 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.
|
|
|
|
from ..llama.configuration_llama import LlamaConfig
|
|
from ..llama.modeling_llama import (
|
|
LlamaAttention,
|
|
LlamaDecoderLayer,
|
|
LlamaForCausalLM,
|
|
LlamaForQuestionAnswering,
|
|
LlamaForSequenceClassification,
|
|
LlamaForTokenClassification,
|
|
LlamaMLP,
|
|
LlamaModel,
|
|
LlamaPreTrainedModel,
|
|
LlamaRMSNorm,
|
|
LlamaRotaryEmbedding,
|
|
)
|
|
|
|
|
|
class MyTestConfig(LlamaConfig):
|
|
pass
|
|
|
|
|
|
class MyTestRMSNorm(LlamaRMSNorm):
|
|
pass
|
|
|
|
|
|
class MyTestRotaryEmbedding(LlamaRotaryEmbedding):
|
|
pass
|
|
|
|
|
|
class MyTestMLP(LlamaMLP):
|
|
pass
|
|
|
|
|
|
class MyTestAttention(LlamaAttention):
|
|
pass
|
|
|
|
|
|
class MyTestDecoderLayer(LlamaDecoderLayer):
|
|
pass
|
|
|
|
|
|
class MyTestPreTrainedModel(LlamaPreTrainedModel):
|
|
pass
|
|
|
|
|
|
class MyTestModel(LlamaModel):
|
|
pass
|
|
|
|
|
|
class MyTestForCausalLM(LlamaForCausalLM):
|
|
pass
|
|
|
|
|
|
class MyTestForSequenceClassification(LlamaForSequenceClassification):
|
|
pass
|
|
|
|
|
|
class MyTestForQuestionAnswering(LlamaForQuestionAnswering):
|
|
pass
|
|
|
|
|
|
class MyTestForTokenClassification(LlamaForTokenClassification):
|
|
pass
|
|
|
|
|
|
__all__ = [
|
|
"MyTestConfig",
|
|
"MyTestForCausalLM",
|
|
"MyTestModel",
|
|
"MyTestPreTrainedModel",
|
|
"MyTestForSequenceClassification",
|
|
"MyTestForQuestionAnswering",
|
|
"MyTestForTokenClassification",
|
|
]
|
|
"""
|
|
)
|
|
self.assertFileIsEqual(EXPECTED_MODULAR, os.path.join(model_repo, "modular_my_test.py"))
|
|
|
|
EXPECTED_INIT = textwrap.dedent(
|
|
f"""
|
|
# coding=utf-8
|
|
# Copyright {CURRENT_YEAR} the HuggingFace Team. All rights reserved.
|
|
#
|
|
# 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.
|
|
|
|
from typing import TYPE_CHECKING
|
|
|
|
from ...utils import _LazyModule
|
|
from ...utils.import_utils import define_import_structure
|
|
|
|
|
|
if TYPE_CHECKING:
|
|
from .configuration_my_test import *
|
|
from .modeling_my_test import *
|
|
else:
|
|
import sys
|
|
|
|
_file = globals()["__file__"]
|
|
sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
|
|
|
|
"""
|
|
)
|
|
self.assertFileIsEqual(EXPECTED_INIT, os.path.join(model_repo, "__init__.py"))
|
|
|
|
EXPECTED_DOC = textwrap.dedent(
|
|
f"""
|
|
<!--Copyright {CURRENT_YEAR} the HuggingFace Team. All rights reserved.
|
|
|
|
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.
|
|
|
|
|
|
⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be rendered properly in your Markdown viewer.
|
|
|
|
-->
|
|
|
|
|
|
# MyTest
|
|
|
|
## Overview
|
|
|
|
The MyTest model was proposed in [<INSERT PAPER NAME HERE>](<INSERT PAPER LINK HERE>) by <INSERT AUTHORS HERE>.
|
|
<INSERT SHORT SUMMARY HERE>
|
|
|
|
The abstract from the paper is the following:
|
|
|
|
<INSERT PAPER ABSTRACT HERE>
|
|
|
|
Tips:
|
|
|
|
<INSERT TIPS ABOUT MODEL HERE>
|
|
|
|
This model was contributed by [INSERT YOUR HF USERNAME HERE](https://huggingface.co/<INSERT YOUR HF USERNAME HERE>).
|
|
The original code can be found [here](<INSERT LINK TO GITHUB REPO HERE>).
|
|
|
|
## Usage examples
|
|
|
|
<INSERT SOME NICE EXAMPLES HERE>
|
|
|
|
## MyTestConfig
|
|
|
|
[[autodoc]] MyTestConfig
|
|
|
|
## MyTestForCausalLM
|
|
|
|
[[autodoc]] MyTestForCausalLM
|
|
|
|
## MyTestModel
|
|
|
|
[[autodoc]] MyTestModel
|
|
- forward
|
|
|
|
## MyTestPreTrainedModel
|
|
|
|
[[autodoc]] MyTestPreTrainedModel
|
|
- forward
|
|
|
|
## MyTestForSequenceClassification
|
|
|
|
[[autodoc]] MyTestForSequenceClassification
|
|
|
|
## MyTestForQuestionAnswering
|
|
|
|
[[autodoc]] MyTestForQuestionAnswering
|
|
|
|
## MyTestForTokenClassification
|
|
|
|
[[autodoc]] MyTestForTokenClassification
|
|
"""
|
|
)
|
|
self.assertFileIsEqual(EXPECTED_DOC, os.path.join(self.DOC_PATH, "model_doc", "my_test.md"))
|
|
|
|
def test_phi4_with_all_processors(self):
|
|
# This is the structure without adding the tokenizers
|
|
filenames_to_add = (
|
|
("configuration_phi4_multimodal.py", True),
|
|
("modeling_phi4_multimodal.py", True),
|
|
("tokenization_phi4_multimodal.py", False),
|
|
("tokenization_phi4_multimodal_fast.py", False),
|
|
("image_processing_phi4_multimodal.py", False),
|
|
("image_processing_phi4_multimodal_fast.py", True),
|
|
("video_processing_phi4_multimodal.py", False),
|
|
("feature_extraction_phi4_multimodal.py", True),
|
|
("processing_phi4_multimodal.py", True),
|
|
)
|
|
# Run the command
|
|
create_new_model_like(
|
|
old_model_infos=ModelInfos("phi4_multimodal"),
|
|
new_lowercase_name="my_test2",
|
|
new_model_paper_name="MyTest2",
|
|
filenames_to_add=filenames_to_add,
|
|
create_fast_image_processor=False,
|
|
)
|
|
|
|
# First assert that all files were created correctly
|
|
model_repo = os.path.join(self.MODEL_PATH, "my_test2")
|
|
tests_repo = os.path.join(self.TESTS_MODEL_PATH, "my_test2")
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "modular_my_test2.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "modeling_my_test2.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "configuration_my_test2.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "image_processing_my_test2_fast.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "feature_extraction_my_test2.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "processing_my_test2.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(model_repo, "__init__.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(self.DOC_PATH, "model_doc", "my_test2.md")))
|
|
self.assertTrue(os.path.isfile(os.path.join(tests_repo, "__init__.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(tests_repo, "test_modeling_my_test2.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(tests_repo, "test_feature_extraction_my_test2.py")))
|
|
self.assertTrue(os.path.isfile(os.path.join(tests_repo, "test_image_processing_my_test2.py")))
|
|
|
|
# Now assert the correct imports/auto mappings/toctree were added
|
|
self.assertInFile(
|
|
"from .my_test2 import *\n",
|
|
os.path.join(self.MODEL_PATH, "__init__.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test2", "MyTest2Config"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "configuration_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test2", "MyTest2"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "configuration_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test2", "MyTest2Model"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "modeling_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test2", "MyTest2ForCausalLM"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "modeling_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test2", (None, "MyTest2ImageProcessorFast")),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "image_processing_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test2", "MyTest2FeatureExtractor"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "feature_extraction_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
'("my_test2", "MyTest2Processor"),\n',
|
|
os.path.join(self.MODEL_PATH, "auto", "processing_auto.py"),
|
|
)
|
|
self.assertInFile(
|
|
"- local: model_doc/my_test2\n title: MyTest2\n",
|
|
os.path.join(self.DOC_PATH, "_toctree.yml"),
|
|
)
|
|
|
|
# Check some exact file creation. For model definition, only check modular as modeling/config/etc... are created
|
|
# directly from it
|
|
EXPECTED_MODULAR = textwrap.dedent(
|
|
f"""
|
|
# coding=utf-8
|
|
# Copyright {CURRENT_YEAR} the HuggingFace Team. All rights reserved.
|
|
#
|
|
# 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.
|
|
|
|
from ..phi4_multimodal.configuration_phi4_multimodal import (
|
|
Phi4MultimodalAudioConfig,
|
|
Phi4MultimodalConfig,
|
|
Phi4MultimodalVisionConfig,
|
|
)
|
|
from ..phi4_multimodal.feature_extraction_phi4_multimodal import Phi4MultimodalFeatureExtractor
|
|
from ..phi4_multimodal.image_processing_phi4_multimodal_fast import (
|
|
Phi4MultimodalFastImageProcessorKwargs,
|
|
Phi4MultimodalImageProcessorFast,
|
|
)
|
|
from ..phi4_multimodal.modeling_phi4_multimodal import (
|
|
Phi4MultimodalAttention,
|
|
Phi4MultimodalAudioAttention,
|
|
Phi4MultimodalAudioConformerEncoderLayer,
|
|
Phi4MultimodalAudioConvModule,
|
|
Phi4MultimodalAudioDepthWiseSeparableConv1d,
|
|
Phi4MultimodalAudioEmbedding,
|
|
Phi4MultimodalAudioGluPointWiseConv,
|
|
Phi4MultimodalAudioMeanVarianceNormLayer,
|
|
Phi4MultimodalAudioMLP,
|
|
Phi4MultimodalAudioModel,
|
|
Phi4MultimodalAudioNemoConvSubsampling,
|
|
Phi4MultimodalAudioPreTrainedModel,
|
|
Phi4MultimodalAudioRelativeAttentionBias,
|
|
Phi4MultimodalDecoderLayer,
|
|
Phi4MultimodalFeatureEmbedding,
|
|
Phi4MultimodalForCausalLM,
|
|
Phi4MultimodalImageEmbedding,
|
|
Phi4MultimodalMLP,
|
|
Phi4MultimodalModel,
|
|
Phi4MultimodalPreTrainedModel,
|
|
Phi4MultimodalRMSNorm,
|
|
Phi4MultimodalRotaryEmbedding,
|
|
Phi4MultimodalVisionAttention,
|
|
Phi4MultimodalVisionEmbeddings,
|
|
Phi4MultimodalVisionEncoder,
|
|
Phi4MultimodalVisionEncoderLayer,
|
|
Phi4MultimodalVisionMLP,
|
|
Phi4MultimodalVisionModel,
|
|
Phi4MultimodalVisionMultiheadAttentionPoolingHead,
|
|
Phi4MultimodalVisionPreTrainedModel,
|
|
)
|
|
from ..phi4_multimodal.processing_phi4_multimodal import Phi4MultimodalProcessor, Phi4MultimodalProcessorKwargs
|
|
|
|
|
|
class MyTest2VisionConfig(Phi4MultimodalVisionConfig):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioConfig(Phi4MultimodalAudioConfig):
|
|
pass
|
|
|
|
|
|
class MyTest2Config(Phi4MultimodalConfig):
|
|
pass
|
|
|
|
|
|
class MyTest2VisionMLP(Phi4MultimodalVisionMLP):
|
|
pass
|
|
|
|
|
|
class MyTest2VisionAttention(Phi4MultimodalVisionAttention):
|
|
pass
|
|
|
|
|
|
class MyTest2VisionEncoderLayer(Phi4MultimodalVisionEncoderLayer):
|
|
pass
|
|
|
|
|
|
class MyTest2VisionEncoder(Phi4MultimodalVisionEncoder):
|
|
pass
|
|
|
|
|
|
class MyTest2VisionPreTrainedModel(Phi4MultimodalVisionPreTrainedModel):
|
|
pass
|
|
|
|
|
|
class MyTest2VisionEmbeddings(Phi4MultimodalVisionEmbeddings):
|
|
pass
|
|
|
|
|
|
class MyTest2VisionMultiheadAttentionPoolingHead(Phi4MultimodalVisionMultiheadAttentionPoolingHead):
|
|
pass
|
|
|
|
|
|
class MyTest2VisionModel(Phi4MultimodalVisionModel):
|
|
pass
|
|
|
|
|
|
class MyTest2ImageEmbedding(Phi4MultimodalImageEmbedding):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioMLP(Phi4MultimodalAudioMLP):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioAttention(Phi4MultimodalAudioAttention):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioDepthWiseSeparableConv1d(Phi4MultimodalAudioDepthWiseSeparableConv1d):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioGluPointWiseConv(Phi4MultimodalAudioGluPointWiseConv):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioConvModule(Phi4MultimodalAudioConvModule):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioConformerEncoderLayer(Phi4MultimodalAudioConformerEncoderLayer):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioNemoConvSubsampling(Phi4MultimodalAudioNemoConvSubsampling):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioRelativeAttentionBias(Phi4MultimodalAudioRelativeAttentionBias):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioMeanVarianceNormLayer(Phi4MultimodalAudioMeanVarianceNormLayer):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioPreTrainedModel(Phi4MultimodalAudioPreTrainedModel):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioModel(Phi4MultimodalAudioModel):
|
|
pass
|
|
|
|
|
|
class MyTest2AudioEmbedding(Phi4MultimodalAudioEmbedding):
|
|
pass
|
|
|
|
|
|
class MyTest2RMSNorm(Phi4MultimodalRMSNorm):
|
|
pass
|
|
|
|
|
|
class MyTest2MLP(Phi4MultimodalMLP):
|
|
pass
|
|
|
|
|
|
class MyTest2Attention(Phi4MultimodalAttention):
|
|
pass
|
|
|
|
|
|
class MyTest2DecoderLayer(Phi4MultimodalDecoderLayer):
|
|
pass
|
|
|
|
|
|
class MyTest2FeatureEmbedding(Phi4MultimodalFeatureEmbedding):
|
|
pass
|
|
|
|
|
|
class MyTest2RotaryEmbedding(Phi4MultimodalRotaryEmbedding):
|
|
pass
|
|
|
|
|
|
class MyTest2PreTrainedModel(Phi4MultimodalPreTrainedModel):
|
|
pass
|
|
|
|
|
|
class MyTest2Model(Phi4MultimodalModel):
|
|
pass
|
|
|
|
|
|
class MyTest2ForCausalLM(Phi4MultimodalForCausalLM):
|
|
pass
|
|
|
|
|
|
class MyTest2FastImageProcessorKwargs(Phi4MultimodalFastImageProcessorKwargs):
|
|
pass
|
|
|
|
|
|
class MyTest2ImageProcessorFast(Phi4MultimodalImageProcessorFast):
|
|
pass
|
|
|
|
|
|
class MyTest2FeatureExtractor(Phi4MultimodalFeatureExtractor):
|
|
pass
|
|
|
|
|
|
class MyTest2ProcessorKwargs(Phi4MultimodalProcessorKwargs):
|
|
pass
|
|
|
|
|
|
class MyTest2Processor(Phi4MultimodalProcessor):
|
|
pass
|
|
|
|
|
|
__all__ = [
|
|
"MyTest2VisionConfig",
|
|
"MyTest2AudioConfig",
|
|
"MyTest2Config",
|
|
"MyTest2AudioPreTrainedModel",
|
|
"MyTest2AudioModel",
|
|
"MyTest2VisionPreTrainedModel",
|
|
"MyTest2VisionModel",
|
|
"MyTest2PreTrainedModel",
|
|
"MyTest2Model",
|
|
"MyTest2ForCausalLM",
|
|
"MyTest2ImageProcessorFast",
|
|
"MyTest2FeatureExtractor",
|
|
"MyTest2Processor",
|
|
]
|
|
"""
|
|
)
|
|
self.assertFileIsEqual(EXPECTED_MODULAR, os.path.join(model_repo, "modular_my_test2.py"))
|
|
|
|
EXPECTED_INIT = textwrap.dedent(
|
|
f"""
|
|
# coding=utf-8
|
|
# Copyright {CURRENT_YEAR} the HuggingFace Team. All rights reserved.
|
|
#
|
|
# 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.
|
|
|
|
from typing import TYPE_CHECKING
|
|
|
|
from ...utils import _LazyModule
|
|
from ...utils.import_utils import define_import_structure
|
|
|
|
|
|
if TYPE_CHECKING:
|
|
from .configuration_my_test2 import *
|
|
from .feature_extraction_my_test2 import *
|
|
from .image_processing_my_test2_fast import *
|
|
from .modeling_my_test2 import *
|
|
from .processing_my_test2 import *
|
|
else:
|
|
import sys
|
|
|
|
_file = globals()["__file__"]
|
|
sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
|
|
"""
|
|
)
|
|
self.assertFileIsEqual(EXPECTED_INIT, os.path.join(model_repo, "__init__.py"))
|
|
|
|
EXPECTED_DOC = textwrap.dedent(
|
|
f"""
|
|
<!--Copyright {CURRENT_YEAR} the HuggingFace Team. All rights reserved.
|
|
|
|
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.
|
|
|
|
|
|
⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be rendered properly in your Markdown viewer.
|
|
|
|
-->
|
|
|
|
|
|
# MyTest2
|
|
|
|
## Overview
|
|
|
|
The MyTest2 model was proposed in [<INSERT PAPER NAME HERE>](<INSERT PAPER LINK HERE>) by <INSERT AUTHORS HERE>.
|
|
<INSERT SHORT SUMMARY HERE>
|
|
|
|
The abstract from the paper is the following:
|
|
|
|
<INSERT PAPER ABSTRACT HERE>
|
|
|
|
Tips:
|
|
|
|
<INSERT TIPS ABOUT MODEL HERE>
|
|
|
|
This model was contributed by [INSERT YOUR HF USERNAME HERE](https://huggingface.co/<INSERT YOUR HF USERNAME HERE>).
|
|
The original code can be found [here](<INSERT LINK TO GITHUB REPO HERE>).
|
|
|
|
## Usage examples
|
|
|
|
<INSERT SOME NICE EXAMPLES HERE>
|
|
|
|
## MyTest2VisionConfig
|
|
|
|
[[autodoc]] MyTest2VisionConfig
|
|
|
|
## MyTest2AudioConfig
|
|
|
|
[[autodoc]] MyTest2AudioConfig
|
|
|
|
## MyTest2Config
|
|
|
|
[[autodoc]] MyTest2Config
|
|
|
|
## MyTest2AudioPreTrainedModel
|
|
|
|
[[autodoc]] MyTest2AudioPreTrainedModel
|
|
- forward
|
|
|
|
## MyTest2AudioModel
|
|
|
|
[[autodoc]] MyTest2AudioModel
|
|
- forward
|
|
|
|
## MyTest2VisionPreTrainedModel
|
|
|
|
[[autodoc]] MyTest2VisionPreTrainedModel
|
|
- forward
|
|
|
|
## MyTest2VisionModel
|
|
|
|
[[autodoc]] MyTest2VisionModel
|
|
- forward
|
|
|
|
## MyTest2PreTrainedModel
|
|
|
|
[[autodoc]] MyTest2PreTrainedModel
|
|
- forward
|
|
|
|
## MyTest2Model
|
|
|
|
[[autodoc]] MyTest2Model
|
|
- forward
|
|
|
|
## MyTest2ForCausalLM
|
|
|
|
[[autodoc]] MyTest2ForCausalLM
|
|
|
|
## MyTest2ImageProcessorFast
|
|
|
|
[[autodoc]] MyTest2ImageProcessorFast
|
|
|
|
## MyTest2FeatureExtractor
|
|
|
|
[[autodoc]] MyTest2FeatureExtractor
|
|
|
|
## MyTest2Processor
|
|
|
|
[[autodoc]] MyTest2Processor
|
|
"""
|
|
)
|
|
self.assertFileIsEqual(EXPECTED_DOC, os.path.join(self.DOC_PATH, "model_doc", "my_test2.md"))
|